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

annotate src/share/vm/gc_interface/collectedHeap.cpp @ 13212:eb03a7335eb0

Use fixed instead of virtual register for target in far foreign call, since the register allocator does not support virtual registers to be used at call sites.

author	Christian Wimmer <christian.wimmer@oracle.com>
date	Mon, 02 Dec 2013 14:20:32 -0800
parents	096c224171c4
children	d8041d695d19

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	2 * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 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"
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	27 #include "gc_implementation/shared/gcHeapSummary.hpp"
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	28 #include "gc_implementation/shared/gcTrace.hpp"
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	29 #include "gc_implementation/shared/gcTraceTime.hpp"
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	30 #include "gc_implementation/shared/gcWhen.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	31 #include "gc_implementation/shared/vmGCOperations.hpp"
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	32 #include "gc_interface/allocTracer.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	33 #include "gc_interface/collectedHeap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	34 #include "gc_interface/collectedHeap.inline.hpp"
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	35 #include "memory/metaspace.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	36 #include "oops/oop.inline.hpp"
4009 e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	37 #include "oops/instanceMirrorKlass.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	38 #include "runtime/init.hpp"
7180 f34d701e952e 8003935: Simplify the needed includes for using Thread::current() stefank parents: 6735 diff changeset	39 #include "runtime/thread.inline.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	40 #include "services/heapDumper.hpp"
0 a61af66fc99e Initial load duke parents: diff changeset	41
a61af66fc99e Initial load duke parents: diff changeset	42
a61af66fc99e Initial load duke parents: diff changeset	43 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	44 int CollectedHeap::_fire_out_of_memory_count = 0;
a61af66fc99e Initial load duke parents: diff changeset	45 #endif
a61af66fc99e Initial load duke parents: diff changeset	46
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	47 size_t CollectedHeap::_filler_array_max_size = 0;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	48
4872 aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4746 diff changeset	49 template <>
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4746 diff changeset	50 void EventLogBase<GCMessage>::print(outputStream* st, GCMessage& m) {
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4746 diff changeset	51 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	52 st->print_raw(m);
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4746 diff changeset	53 }
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4746 diff changeset	54
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4746 diff changeset	55 void GCHeapLog::log_heap(bool before) {
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4746 diff changeset	56 if (!should_log()) {
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4746 diff changeset	57 return;
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4746 diff changeset	58 }
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4746 diff changeset	59
4944 09d00c18e323 7145537: minor tweaks to LogEvents never parents: 4872 diff changeset	60 double timestamp = fetch_timestamp();
4872 aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4746 diff changeset	61 MutexLockerEx ml(&_mutex, Mutex::_no_safepoint_check_flag);
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4746 diff changeset	62 int index = compute_log_index();
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4746 diff changeset	63 _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	64 _records[index].timestamp = timestamp;
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4746 diff changeset	65 _records[index].data.is_before = before;
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4746 diff changeset	66 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	67 if (before) {
4944 09d00c18e323 7145537: minor tweaks to LogEvents never parents: 4872 diff changeset	68 Universe::print_heap_before_gc(&st, true);
4872 aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4746 diff changeset	69 } else {
4944 09d00c18e323 7145537: minor tweaks to LogEvents never parents: 4872 diff changeset	70 Universe::print_heap_after_gc(&st, true);
4872 aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4746 diff changeset	71 }
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4746 diff changeset	72 }
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4746 diff changeset	73
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	74 VirtualSpaceSummary CollectedHeap::create_heap_space_summary() {
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	75 size_t capacity_in_words = capacity() / HeapWordSize;
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	76
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	77 return VirtualSpaceSummary(
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	78 reserved_region().start(), reserved_region().start() + capacity_in_words, reserved_region().end());
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	79 }
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	80
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	81 GCHeapSummary CollectedHeap::create_heap_summary() {
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	82 VirtualSpaceSummary heap_space = create_heap_space_summary();
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	83 return GCHeapSummary(heap_space, used());
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	84 }
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	85
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	86 MetaspaceSummary CollectedHeap::create_metaspace_summary() {
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	87 const MetaspaceSizes meta_space(
11116 27c53c9f3a7e 8013939: Metaspace capacity not available ehelin parents: 10405 diff changeset	88 MetaspaceAux::allocated_capacity_bytes(),
27c53c9f3a7e 8013939: Metaspace capacity not available ehelin parents: 10405 diff changeset	89 MetaspaceAux::allocated_used_bytes(),
12235 d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12080 diff changeset	90 MetaspaceAux::reserved_bytes());
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	91 const MetaspaceSizes data_space(
11116 27c53c9f3a7e 8013939: Metaspace capacity not available ehelin parents: 10405 diff changeset	92 MetaspaceAux::allocated_capacity_bytes(Metaspace::NonClassType),
27c53c9f3a7e 8013939: Metaspace capacity not available ehelin parents: 10405 diff changeset	93 MetaspaceAux::allocated_used_bytes(Metaspace::NonClassType),
12235 d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12080 diff changeset	94 MetaspaceAux::reserved_bytes(Metaspace::NonClassType));
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	95 const MetaspaceSizes class_space(
11116 27c53c9f3a7e 8013939: Metaspace capacity not available ehelin parents: 10405 diff changeset	96 MetaspaceAux::allocated_capacity_bytes(Metaspace::ClassType),
27c53c9f3a7e 8013939: Metaspace capacity not available ehelin parents: 10405 diff changeset	97 MetaspaceAux::allocated_used_bytes(Metaspace::ClassType),
12235 d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12080 diff changeset	98 MetaspaceAux::reserved_bytes(Metaspace::ClassType));
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	99
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	100 return MetaspaceSummary(meta_space, data_space, class_space);
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	101 }
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	102
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	103 void CollectedHeap::print_heap_before_gc() {
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	104 if (PrintHeapAtGC) {
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	105 Universe::print_heap_before_gc();
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	106 }
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	107 if (_gc_heap_log != NULL) {
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	108 _gc_heap_log->log_heap_before();
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	109 }
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	110 }
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	111
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	112 void CollectedHeap::print_heap_after_gc() {
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	113 if (PrintHeapAtGC) {
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	114 Universe::print_heap_after_gc();
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	115 }
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	116 if (_gc_heap_log != NULL) {
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	117 _gc_heap_log->log_heap_after();
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	118 }
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	119 }
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	120
12080 5888334c9c24 7145569: G1: optimize nmethods scanning johnc parents: 11116 diff changeset	121 void CollectedHeap::register_nmethod(nmethod* nm) {
5888334c9c24 7145569: G1: optimize nmethods scanning johnc parents: 11116 diff changeset	122 assert_locked_or_safepoint(CodeCache_lock);
5888334c9c24 7145569: G1: optimize nmethods scanning johnc parents: 11116 diff changeset	123 }
5888334c9c24 7145569: G1: optimize nmethods scanning johnc parents: 11116 diff changeset	124
5888334c9c24 7145569: G1: optimize nmethods scanning johnc parents: 11116 diff changeset	125 void CollectedHeap::unregister_nmethod(nmethod* nm) {
5888334c9c24 7145569: G1: optimize nmethods scanning johnc parents: 11116 diff changeset	126 assert_locked_or_safepoint(CodeCache_lock);
5888334c9c24 7145569: G1: optimize nmethods scanning johnc parents: 11116 diff changeset	127 }
5888334c9c24 7145569: G1: optimize nmethods scanning johnc parents: 11116 diff changeset	128
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	129 void CollectedHeap::trace_heap(GCWhen::Type when, GCTracer* gc_tracer) {
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	130 const GCHeapSummary& heap_summary = create_heap_summary();
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	131 const MetaspaceSummary& metaspace_summary = create_metaspace_summary();
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	132 gc_tracer->report_gc_heap_summary(when, heap_summary, metaspace_summary);
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	133 }
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	134
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	135 void CollectedHeap::trace_heap_before_gc(GCTracer* gc_tracer) {
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	136 trace_heap(GCWhen::BeforeGC, gc_tracer);
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	137 }
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	138
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	139 void CollectedHeap::trace_heap_after_gc(GCTracer* gc_tracer) {
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	140 trace_heap(GCWhen::AfterGC, gc_tracer);
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	141 }
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	142
0 a61af66fc99e Initial load duke parents: diff changeset	143 // Memory state functions.
a61af66fc99e Initial load duke parents: diff changeset	144
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1579 diff changeset	145
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1579 diff changeset	146 CollectedHeap::CollectedHeap() : _n_par_threads(0)
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	147 {
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	148 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	149 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	150 _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	151 max_len / elements_per_word);
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	152
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	153 _barrier_set = NULL;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	154 _is_gc_active = false;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	155 _total_collections = _total_full_collections = 0;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	156 _gc_cause = _gc_lastcause = GCCause::_no_gc;
0 a61af66fc99e Initial load duke parents: diff changeset	157 NOT_PRODUCT(_promotion_failure_alot_count = 0;)
a61af66fc99e Initial load duke parents: diff changeset	158 NOT_PRODUCT(_promotion_failure_alot_gc_number = 0;)
a61af66fc99e Initial load duke parents: diff changeset	159
a61af66fc99e Initial load duke parents: diff changeset	160 if (UsePerfData) {
a61af66fc99e Initial load duke parents: diff changeset	161 EXCEPTION_MARK;
a61af66fc99e Initial load duke parents: diff changeset	162
a61af66fc99e Initial load duke parents: diff changeset	163 // create the gc cause jvmstat counters
a61af66fc99e Initial load duke parents: diff changeset	164 _perf_gc_cause = PerfDataManager::create_string_variable(SUN_GC, "cause",
a61af66fc99e Initial load duke parents: diff changeset	165 80, GCCause::to_string(_gc_cause), CHECK);
a61af66fc99e Initial load duke parents: diff changeset	166
a61af66fc99e Initial load duke parents: diff changeset	167 _perf_gc_lastcause =
a61af66fc99e Initial load duke parents: diff changeset	168 PerfDataManager::create_string_variable(SUN_GC, "lastCause",
a61af66fc99e Initial load duke parents: diff changeset	169 80, GCCause::to_string(_gc_lastcause), CHECK);
a61af66fc99e Initial load duke parents: diff changeset	170 }
1166 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	171 _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	172 // Create the ring log
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4746 diff changeset	173 if (LogEvents) {
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4746 diff changeset	174 _gc_heap_log = new GCHeapLog();
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4746 diff changeset	175 } else {
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4746 diff changeset	176 _gc_heap_log = NULL;
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4746 diff changeset	177 }
0 a61af66fc99e Initial load duke parents: diff changeset	178 }
a61af66fc99e Initial load duke parents: diff changeset	179
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5972 diff changeset	180 // 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	181 // 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	182 // 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	183 // the context of the vm thread.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5972 diff changeset	184 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	185 assert(Thread::current()->is_VM_thread(), "Precondition#1");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5972 diff changeset	186 assert(Heap_lock->is_locked(), "Precondition#2");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5972 diff changeset	187 GCCauseSetter gcs(this, cause);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5972 diff changeset	188 switch (cause) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5972 diff changeset	189 case GCCause::_heap_inspection:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5972 diff changeset	190 case GCCause::_heap_dump:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5972 diff changeset	191 case GCCause::_metadata_GC_threshold : {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5972 diff changeset	192 HandleMark hm;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5972 diff changeset	193 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	194 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5972 diff changeset	195 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5972 diff changeset	196 case GCCause::_last_ditch_collection: {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5972 diff changeset	197 HandleMark hm;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5972 diff changeset	198 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	199 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5972 diff changeset	200 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5972 diff changeset	201 default:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5972 diff changeset	202 ShouldNotReachHere(); // Unexpected use of this function
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5972 diff changeset	203 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5972 diff changeset	204 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5972 diff changeset	205
1166 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	206 void CollectedHeap::pre_initialize() {
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	207 // Used for ReduceInitialCardMarks (when COMPILER2 is used);
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	208 // otherwise remains unused.
1548 15190cbcabe9 6953483: Typo related to ReduceInitialCardMarks leaves concurrent collectors vulnerable to heap corruption ysr parents: 1194 diff changeset	209 #ifdef COMPILER2
1194 34fb2662f6c2 6920090: G1: Disable ReduceInitialCardMarks at least until 6920109 is fixed ysr parents: 1166 diff changeset	210 _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	211 && (DeferInitialCardMark \|\| card_mark_must_follow_store());
12375 819c0394c6e3 Fix warning Christos Kotselidis <christos.kotselidis@oracle.com> parents: 12372 diff changeset	212 #elif defined GRAAL
12367 c4af81d4fcc3 Customize deferred barrier flags fro Graal Christos Kotselidis <christos.kotselidis@oracle.com> parents: 11116 diff changeset	213 _defer_initial_card_mark = GraalDeferredInitBarriers && can_elide_tlab_store_barriers()
c4af81d4fcc3 Customize deferred barrier flags fro Graal Christos Kotselidis <christos.kotselidis@oracle.com> parents: 11116 diff changeset	214 && (DeferInitialCardMark \|\| card_mark_must_follow_store());
1166 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	215 #else
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	216 assert(_defer_initial_card_mark == false, "Who would set it?");
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	217 #endif
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	218 }
0 a61af66fc99e Initial load duke parents: diff changeset	219
a61af66fc99e Initial load duke parents: diff changeset	220 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	221 void CollectedHeap::check_for_bad_heap_word_value(HeapWord* addr, size_t size) {
a61af66fc99e Initial load duke parents: diff changeset	222 if (CheckMemoryInitialization && ZapUnusedHeapArea) {
a61af66fc99e Initial load duke parents: diff changeset	223 for (size_t slot = 0; slot < size; slot += 1) {
a61af66fc99e Initial load duke parents: diff changeset	224 assert(((intptr_t) (addr + slot)) != ((intptr_t) badHeapWordVal),
a61af66fc99e Initial load duke parents: diff changeset	225 "Found badHeapWordValue in post-allocation check");
a61af66fc99e Initial load duke parents: diff changeset	226 }
a61af66fc99e Initial load duke parents: diff changeset	227 }
a61af66fc99e Initial load duke parents: diff changeset	228 }
a61af66fc99e Initial load duke parents: diff changeset	229
2226 c5a923563727 6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?") ysr parents: 1972 diff changeset	230 void CollectedHeap::check_for_non_bad_heap_word_value(HeapWord* addr, size_t size) {
0 a61af66fc99e Initial load duke parents: diff changeset	231 if (CheckMemoryInitialization && ZapUnusedHeapArea) {
a61af66fc99e Initial load duke parents: diff changeset	232 for (size_t slot = 0; slot < size; slot += 1) {
a61af66fc99e Initial load duke parents: diff changeset	233 assert(((intptr_t) (addr + slot)) == ((intptr_t) badHeapWordVal),
a61af66fc99e Initial load duke parents: diff changeset	234 "Found non badHeapWordValue in pre-allocation check");
a61af66fc99e Initial load duke parents: diff changeset	235 }
a61af66fc99e Initial load duke parents: diff changeset	236 }
a61af66fc99e Initial load duke parents: diff changeset	237 }
a61af66fc99e Initial load duke parents: diff changeset	238 #endif // PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	239
a61af66fc99e Initial load duke parents: diff changeset	240 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	241 void CollectedHeap::check_for_valid_allocation_state() {
a61af66fc99e Initial load duke parents: diff changeset	242 Thread *thread = Thread::current();
a61af66fc99e Initial load duke parents: diff changeset	243 // How to choose between a pending exception and a potential
a61af66fc99e Initial load duke parents: diff changeset	244 // OutOfMemoryError? Don't allow pending exceptions.
a61af66fc99e Initial load duke parents: diff changeset	245 // This is a VM policy failure, so how do we exhaustively test it?
a61af66fc99e Initial load duke parents: diff changeset	246 assert(!thread->has_pending_exception(),
a61af66fc99e Initial load duke parents: diff changeset	247 "shouldn't be allocating with pending exception");
a61af66fc99e Initial load duke parents: diff changeset	248 if (StrictSafepointChecks) {
a61af66fc99e Initial load duke parents: diff changeset	249 assert(thread->allow_allocation(),
a61af66fc99e Initial load duke parents: diff changeset	250 "Allocation done by thread for which allocation is blocked "
a61af66fc99e Initial load duke parents: diff changeset	251 "by No_Allocation_Verifier!");
a61af66fc99e Initial load duke parents: diff changeset	252 // Allocation of an oop can always invoke a safepoint,
a61af66fc99e Initial load duke parents: diff changeset	253 // hence, the true argument
a61af66fc99e Initial load duke parents: diff changeset	254 thread->check_for_valid_safepoint_state(true);
a61af66fc99e Initial load duke parents: diff changeset	255 }
a61af66fc99e Initial load duke parents: diff changeset	256 }
a61af66fc99e Initial load duke parents: diff changeset	257 #endif
a61af66fc99e Initial load duke parents: diff changeset	258
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	259 HeapWord* CollectedHeap::allocate_from_tlab_slow(KlassHandle klass, Thread* thread, size_t size) {
0 a61af66fc99e Initial load duke parents: diff changeset	260
a61af66fc99e Initial load duke parents: diff changeset	261 // Retain tlab and allocate object in shared space if
a61af66fc99e Initial load duke parents: diff changeset	262 // the amount free in the tlab is too large to discard.
a61af66fc99e Initial load duke parents: diff changeset	263 if (thread->tlab().free() > thread->tlab().refill_waste_limit()) {
a61af66fc99e Initial load duke parents: diff changeset	264 thread->tlab().record_slow_allocation(size);
a61af66fc99e Initial load duke parents: diff changeset	265 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	266 }
a61af66fc99e Initial load duke parents: diff changeset	267
a61af66fc99e Initial load duke parents: diff changeset	268 // Discard tlab and allocate a new one.
a61af66fc99e Initial load duke parents: diff changeset	269 // To minimize fragmentation, the last TLAB may be smaller than the rest.
a61af66fc99e Initial load duke parents: diff changeset	270 size_t new_tlab_size = thread->tlab().compute_size(size);
a61af66fc99e Initial load duke parents: diff changeset	271
a61af66fc99e Initial load duke parents: diff changeset	272 thread->tlab().clear_before_allocation();
a61af66fc99e Initial load duke parents: diff changeset	273
a61af66fc99e Initial load duke parents: diff changeset	274 if (new_tlab_size == 0) {
a61af66fc99e Initial load duke parents: diff changeset	275 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	276 }
a61af66fc99e Initial load duke parents: diff changeset	277
a61af66fc99e Initial load duke parents: diff changeset	278 // Allocate a new TLAB...
a61af66fc99e Initial load duke parents: diff changeset	279 HeapWord* obj = Universe::heap()->allocate_new_tlab(new_tlab_size);
a61af66fc99e Initial load duke parents: diff changeset	280 if (obj == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	281 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	282 }
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	283
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	284 AllocTracer::send_allocation_in_new_tlab_event(klass, new_tlab_size * HeapWordSize, size * HeapWordSize);
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	285
0 a61af66fc99e Initial load duke parents: diff changeset	286 if (ZeroTLAB) {
a61af66fc99e Initial load duke parents: diff changeset	287 // ..and clear it.
a61af66fc99e Initial load duke parents: diff changeset	288 Copy::zero_to_words(obj, new_tlab_size);
a61af66fc99e Initial load duke parents: diff changeset	289 } else {
3892 baf763f388e6 7059037: Use BIS for zeroing on T4 kvn parents: 2426 diff changeset	290 // ...and zap just allocated object.
baf763f388e6 7059037: Use BIS for zeroing on T4 kvn parents: 2426 diff changeset	291 #ifdef ASSERT
baf763f388e6 7059037: Use BIS for zeroing on T4 kvn parents: 2426 diff changeset	292 // Skip mangling the space corresponding to the object header to
baf763f388e6 7059037: Use BIS for zeroing on T4 kvn parents: 2426 diff changeset	293 // ensure that the returned space is not considered parsable by
baf763f388e6 7059037: Use BIS for zeroing on T4 kvn parents: 2426 diff changeset	294 // any concurrent GC thread.
baf763f388e6 7059037: Use BIS for zeroing on T4 kvn parents: 2426 diff changeset	295 size_t hdr_size = oopDesc::header_size();
baf763f388e6 7059037: Use BIS for zeroing on T4 kvn parents: 2426 diff changeset	296 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	297 #endif // ASSERT
0 a61af66fc99e Initial load duke parents: diff changeset	298 }
a61af66fc99e Initial load duke parents: diff changeset	299 thread->tlab().fill(obj, obj + size, new_tlab_size);
a61af66fc99e Initial load duke parents: diff changeset	300 return obj;
a61af66fc99e Initial load duke parents: diff changeset	301 }
a61af66fc99e Initial load duke parents: diff changeset	302
1027 39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	303 void CollectedHeap::flush_deferred_store_barrier(JavaThread* thread) {
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	304 MemRegion deferred = thread->deferred_card_mark();
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	305 if (!deferred.is_empty()) {
1166 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	306 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	307 {
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	308 // 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	309 DEBUG_ONLY(oop old_obj = oop(deferred.start());)
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	310 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	311 assert(!can_elide_initializing_store_barrier(old_obj),
1166 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	312 "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	313 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	314 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	315 "Mismatch: multiple objects?");
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	316 }
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	317 BarrierSet* bs = barrier_set();
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	318 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	319 bs->write_region(deferred);
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	320 // "Clear" the deferred_card_mark field
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	321 thread->set_deferred_card_mark(MemRegion());
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	322 }
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	323 assert(thread->deferred_card_mark().is_empty(), "invariant");
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	324 }
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	325
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	326 // Helper for ReduceInitialCardMarks. For performance,
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	327 // 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	328 // 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	329 // compensate for such elided card-marks as follows:
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	330 // (a) Generational, non-concurrent collectors, such as
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	331 // GenCollectedHeap(ParNew,DefNew,Tenured) and
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	332 // ParallelScavengeHeap(ParallelGC, ParallelOldGC)
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	333 // 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	334 // 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	335 // succeeds or precedes the initializing stores themselves,
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	336 // 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	337 // 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	338 // 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	339 // 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	340 // (b) GenCollectedHeap(ConcurrentMarkSweepGeneration) requires
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	341 // 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	342 // object strictly follow any associated initializing stores.
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	343 // In these cases, the memRegion remembered below is
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	344 // 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	345 // 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	346 // 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	347 // (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	348 // 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	349 // card-mark.)
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	350 // (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	351 // 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	352 // 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	353 // 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	354 // 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	355 // 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	356 // 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	357 // 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	358 // 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	359 // 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	360 // (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	361 // Thus, using the same protocol for maintaining the intended
1166 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	362 // invariants turns out, serendepitously, to be the same for both
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	363 // G1 and CMS.
1027 39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	364 //
1166 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	365 // For any future collector, this code should be reexamined with
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	366 // that specific collector in mind, and the documentation above suitably
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	367 // extended and updated.
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	368 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	369 // 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	370 flush_deferred_store_barrier(thread);
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	371 if (can_elide_initializing_store_barrier(new_obj)) {
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	372 // The deferred_card_mark region should be empty
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	373 // following the flush above.
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	374 assert(thread->deferred_card_mark().is_empty(), "Error");
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	375 } else {
1166 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	376 MemRegion mr((HeapWord*)new_obj, new_obj->size());
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	377 assert(!mr.is_empty(), "Error");
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	378 if (_defer_initial_card_mark) {
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	379 // Defer the card mark
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	380 thread->set_deferred_card_mark(mr);
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	381 } else {
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	382 // Do the card mark
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	383 BarrierSet* bs = barrier_set();
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	384 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	385 bs->write_region(mr);
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	386 }
1027 39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	387 }
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	388 return new_obj;
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	389 }
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 628 diff changeset	390
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	391 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	392 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	393 }
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	394
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	395 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	396 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	397 }
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	398
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	399 #ifdef ASSERT
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	400 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	401 {
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	402 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	403 assert(words % MinObjAlignment == 0, "unaligned size");
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	404 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	405 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	406 }
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	407
1165 2dd52dea6d28 6902115: G1:assert(ignore_max_completed\|\|thread->is_Java_thread()\|\|SafepointSynchronize::is_at_safepoint()) johnc parents: 1142 diff changeset	408 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	409 {
1165 2dd52dea6d28 6902115: G1:assert(ignore_max_completed\|\|thread->is_Java_thread()\|\|SafepointSynchronize::is_at_safepoint()) johnc parents: 1142 diff changeset	410 if (ZapFillerObjects && zap) {
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	411 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	412 words - filler_array_hdr_size(), 0XDEAFBABE);
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	413 }
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	414 }
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	415 #endif // ASSERT
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	416
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	417 void
1165 2dd52dea6d28 6902115: G1:assert(ignore_max_completed\|\|thread->is_Java_thread()\|\|SafepointSynchronize::is_at_safepoint()) johnc parents: 1142 diff changeset	418 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	419 {
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	420 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	421 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	422
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	423 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	424 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	425 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	426
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	427 // Set the length first for concurrent GC.
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	428 ((arrayOop)start)->set_length((int)len);
5972 9a9bb0010c91 7156764: Remove unused size parameter from some CollectedHeap methods brutisso parents: 5965 diff changeset	429 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	430 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	431 }
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	432
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	433 void
1165 2dd52dea6d28 6902115: G1:assert(ignore_max_completed\|\|thread->is_Java_thread()\|\|SafepointSynchronize::is_at_safepoint()) johnc parents: 1142 diff changeset	434 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	435 {
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	436 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	437
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	438 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	439 fill_with_array(start, words, zap);
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	440 } else if (words > 0) {
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	441 assert(words == min_fill_size(), "unaligned size");
5972 9a9bb0010c91 7156764: Remove unused size parameter from some CollectedHeap methods brutisso parents: 5965 diff changeset	442 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	443 }
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	444 }
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	445
1165 2dd52dea6d28 6902115: G1:assert(ignore_max_completed\|\|thread->is_Java_thread()\|\|SafepointSynchronize::is_at_safepoint()) johnc parents: 1142 diff changeset	446 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	447 {
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	448 DEBUG_ONLY(fill_args_check(start, words);)
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	449 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	450 fill_with_object_impl(start, words, zap);
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	451 }
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	452
1165 2dd52dea6d28 6902115: G1:assert(ignore_max_completed\|\|thread->is_Java_thread()\|\|SafepointSynchronize::is_at_safepoint()) johnc parents: 1142 diff changeset	453 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	454 {
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	455 DEBUG_ONLY(fill_args_check(start, words);)
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	456 HandleMark hm; // Free handles before leaving.
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	457
1549 1634cec09505 6953952: collectedHeap.cpp should use #ifdef _LP64 not LP64 ysr parents: 1548 diff changeset	458 #ifdef _LP64
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	459 // 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	460 // 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	461 // 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	462 const size_t min = min_fill_size();
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	463 const size_t max = filler_array_max_size();
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	464 while (words > max) {
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	465 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	466 fill_with_array(start, cur, zap);
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	467 start += cur;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	468 words -= cur;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	469 }
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	470 #endif
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	471
1165 2dd52dea6d28 6902115: G1:assert(ignore_max_completed\|\|thread->is_Java_thread()\|\|SafepointSynchronize::is_at_safepoint()) johnc parents: 1142 diff changeset	472 fill_with_object_impl(start, words, zap);
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	473 }
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	474
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 12838 diff changeset	475 void CollectedHeap::post_initialize() {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 12838 diff changeset	476 collector_policy()->post_heap_initialize();
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 12838 diff changeset	477 }
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 12838 diff changeset	478
0 a61af66fc99e Initial load duke parents: diff changeset	479 HeapWord* CollectedHeap::allocate_new_tlab(size_t size) {
a61af66fc99e Initial load duke parents: diff changeset	480 guarantee(false, "thread-local allocation buffers not supported");
a61af66fc99e Initial load duke parents: diff changeset	481 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	482 }
a61af66fc99e Initial load duke parents: diff changeset	483
a61af66fc99e Initial load duke parents: diff changeset	484 void CollectedHeap::ensure_parsability(bool retire_tlabs) {
a61af66fc99e Initial load duke parents: diff changeset	485 // The second disjunct in the assertion below makes a concession
a61af66fc99e Initial load duke parents: diff changeset	486 // for the start-up verification done while the VM is being
a61af66fc99e Initial load duke parents: diff changeset	487 // created. Callers be careful that you know that mutators
a61af66fc99e Initial load duke parents: diff changeset	488 // aren't going to interfere -- for instance, this is permissible
a61af66fc99e Initial load duke parents: diff changeset	489 // if we are still single-threaded and have either not yet
a61af66fc99e Initial load duke parents: diff changeset	490 // started allocating (nothing much to verify) or we have
a61af66fc99e Initial load duke parents: diff changeset	491 // started allocating but are now a full-fledged JavaThread
a61af66fc99e Initial load duke parents: diff changeset	492 // (and have thus made our TLAB's) available for filling.
a61af66fc99e Initial load duke parents: diff changeset	493 assert(SafepointSynchronize::is_at_safepoint() \|\|
a61af66fc99e Initial load duke parents: diff changeset	494 !is_init_completed(),
a61af66fc99e Initial load duke parents: diff changeset	495 "Should only be called at a safepoint or at start-up"
a61af66fc99e Initial load duke parents: diff changeset	496 " otherwise concurrent mutator activity may make heap "
a61af66fc99e Initial load duke parents: diff changeset	497 " unparsable again");
1166 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	498 const bool use_tlab = UseTLAB;
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	499 const bool deferred = _defer_initial_card_mark;
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	500 // 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	501 // 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	502 assert(!use_tlab \|\| Threads::first() != NULL,
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	503 "Attempt to fill tlabs before main thread has been added"
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	504 " to threads list is doomed to failure!");
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	505 for (JavaThread *thread = Threads::first(); thread; thread = thread->next()) {
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	506 if (use_tlab) thread->tlab().make_parsable(retire_tlabs);
12498 d00c31d8394f Flush deferred barrier when Graal and G1 are used Christos Kotselidis <christos.kotselidis@oracle.com> parents: 12375 diff changeset	507 #if defined(COMPILER2) \|\| defined(GRAAL)
1166 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	508 // 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	509 // card-table (or other remembered set structure) before GC starts
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	510 // processing the card-table (or other remembered set).
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	511 if (deferred) flush_deferred_store_barrier(thread);
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	512 #else
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	513 assert(!deferred, "Should be false");
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	514 assert(thread->deferred_card_mark().is_empty(), "Should be empty");
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	515 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	516 }
a61af66fc99e Initial load duke parents: diff changeset	517 }
a61af66fc99e Initial load duke parents: diff changeset	518
a61af66fc99e Initial load duke parents: diff changeset	519 void CollectedHeap::accumulate_statistics_all_tlabs() {
a61af66fc99e Initial load duke parents: diff changeset	520 if (UseTLAB) {
a61af66fc99e Initial load duke parents: diff changeset	521 assert(SafepointSynchronize::is_at_safepoint() \|\|
a61af66fc99e Initial load duke parents: diff changeset	522 !is_init_completed(),
a61af66fc99e Initial load duke parents: diff changeset	523 "should only accumulate statistics on tlabs at safepoint");
a61af66fc99e Initial load duke parents: diff changeset	524
a61af66fc99e Initial load duke parents: diff changeset	525 ThreadLocalAllocBuffer::accumulate_statistics_before_gc();
a61af66fc99e Initial load duke parents: diff changeset	526 }
a61af66fc99e Initial load duke parents: diff changeset	527 }
a61af66fc99e Initial load duke parents: diff changeset	528
a61af66fc99e Initial load duke parents: diff changeset	529 void CollectedHeap::resize_all_tlabs() {
a61af66fc99e Initial load duke parents: diff changeset	530 if (UseTLAB) {
a61af66fc99e Initial load duke parents: diff changeset	531 assert(SafepointSynchronize::is_at_safepoint() \|\|
a61af66fc99e Initial load duke parents: diff changeset	532 !is_init_completed(),
a61af66fc99e Initial load duke parents: diff changeset	533 "should only resize tlabs at safepoint");
a61af66fc99e Initial load duke parents: diff changeset	534
a61af66fc99e Initial load duke parents: diff changeset	535 ThreadLocalAllocBuffer::resize_all_tlabs();
a61af66fc99e Initial load duke parents: diff changeset	536 }
a61af66fc99e Initial load duke parents: diff changeset	537 }
615 c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 494 diff changeset	538
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	539 void CollectedHeap::pre_full_gc_dump(GCTimer* timer) {
615 c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 494 diff changeset	540 if (HeapDumpBeforeFullGC) {
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	541 GCTraceTime tt("Heap Dump (before full gc): ", PrintGCDetails, false, timer);
615 c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 494 diff changeset	542 // 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	543 // major collection has been requested.
c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 494 diff changeset	544 HeapDumper::dump_heap();
c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 494 diff changeset	545 }
c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 494 diff changeset	546 if (PrintClassHistogramBeforeFullGC) {
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	547 GCTraceTime tt("Class Histogram (before full gc): ", PrintGCDetails, true, timer);
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	548 VM_GC_HeapInspection inspector(gclog_or_tty, false /* ! full gc */);
615 c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 494 diff changeset	549 inspector.doit();
c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 494 diff changeset	550 }
c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 494 diff changeset	551 }
c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 494 diff changeset	552
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	553 void CollectedHeap::post_full_gc_dump(GCTimer* timer) {
615 c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 494 diff changeset	554 if (HeapDumpAfterFullGC) {
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	555 GCTraceTime tt("Heap Dump (after full gc): ", PrintGCDetails, false, timer);
615 c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 494 diff changeset	556 HeapDumper::dump_heap();
c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 494 diff changeset	557 }
c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 494 diff changeset	558 if (PrintClassHistogramAfterFullGC) {
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	559 GCTraceTime tt("Class Histogram (after full gc): ", PrintGCDetails, true, timer);
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	560 VM_GC_HeapInspection inspector(gclog_or_tty, false /* ! full gc */);
615 c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 494 diff changeset	561 inspector.doit();
c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 494 diff changeset	562 }
c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 494 diff changeset	563 }
4009 e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	564
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	565 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	566 debug_only(check_for_valid_allocation_state());
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	567 assert(!Universe::heap()->is_gc_active(), "Allocation during gc not allowed");
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	568 assert(size >= 0, "int won't convert to size_t");
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	569 HeapWord* obj;
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	570 assert(ScavengeRootsInCode > 0, "must be");
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 7180 diff changeset	571 obj = common_mem_allocate_init(real_klass, size, CHECK_NULL);
5972 9a9bb0010c91 7156764: Remove unused size parameter from some CollectedHeap methods brutisso parents: 5965 diff changeset	572 post_allocation_setup_common(klass, obj);
4009 e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	573 assert(Universe::is_bootstrapping() \|\|
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5972 diff changeset	574 !((oop)obj)->is_array(), "must not be an array");
4009 e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	575 NOT_PRODUCT(Universe::heap()->check_for_bad_heap_word_value(obj, size));
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	576 oop mirror = (oop)obj;
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	577
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	578 java_lang_Class::set_oop_size(mirror, size);
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	579
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	580 // Setup indirections
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	581 if (!real_klass.is_null()) {
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	582 java_lang_Class::set_klass(mirror, real_klass());
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	583 real_klass->set_java_mirror(mirror);
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	584 }
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	585
6735 aed758eda82a 7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass coleenp parents: 6725 diff changeset	586 InstanceMirrorKlass* mk = InstanceMirrorKlass::cast(mirror->klass());
4009 e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	587 assert(size == mk->instance_size(real_klass), "should have been set");
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	588
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	589 // notify jvmti and dtrace
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	590 post_allocation_notify(klass, (oop)obj);
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	591
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	592 return mirror;
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3960 diff changeset	593 }
4708 3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	594
3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	595 /////////////// Unit tests ///////////////
3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	596
3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	597 #ifndef PRODUCT
3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	598 void CollectedHeap::test_is_in() {
3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	599 CollectedHeap* heap = Universe::heap();
3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	600
4746 b6a04c79ccbc 7125503: Compiling collectedHeap.cpp fails with -Werror=int-to-pointer-cast with g++ 4.6.1 stefank parents: 4708 diff changeset	601 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	602 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	603 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	604
4708 3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	605 // Test that NULL is not in the heap.
3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	606 assert(!heap->is_in(NULL), "NULL is unexpectedly in the heap");
3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	607
3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	608 // 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	609 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	610 void* before_heap = (void*)(heap_start - epsilon);
4708 3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	611 assert(!heap->is_in(before_heap),
3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	612 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	613
3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	614 // 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	615 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	616 void* after_heap = (void*)(heap_end + epsilon);
4708 3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	617 assert(!heap->is_in(after_heap),
3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	618 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	619 }
3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4009 diff changeset	620 #endif

Mercurial > hg > truffle

annotate src/share/vm/gc_interface/collectedHeap.cpp @ 13212:eb03a7335eb0