graal-jvmci-8: src/share/vm/gc_implementation/shared/markSweep.cpp annotate

annotate src/share/vm/gc_implementation/shared/markSweep.cpp @ 10374:87c64c0438fb

6976350: G1: deal with fragmentation while copying objects during GC Summary: Create G1ParGCAllocBufferContainer to contain two buffers instead of previously using one buffer, in order to hold the first priority buffer longer. Thus, when some large objects hits the value of free space left in the first priority buffer it has an alternative to fit in the second priority buffer while the first priority buffer is given more chances to try allocating smaller objects. Overall, it will improve heap space efficiency. Reviewed-by: johnc, jmasa, brutisso Contributed-by: tamao <tao.mao@oracle.com>

author	tamao
date	Mon, 03 Jun 2013 14:37:13 -0700
parents	2138a2c14831
children	f2110083203d

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
10265 92ef81e2f571 8003557: NPG: Klass* const k should be const Klass* k. minqi parents: 10179 diff changeset	2 * Copyright (c) 1997, 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: 1315 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1315 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: 1315 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: 1836 diff changeset	25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	26 #include "compiler/compileBroker.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	27 #include "gc_implementation/shared/markSweep.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	28 #include "gc_interface/collectedHeap.inline.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	29 #include "oops/methodData.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	30 #include "oops/objArrayKlass.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	31 #include "oops/oop.inline.hpp"
0 a61af66fc99e Initial load duke parents: diff changeset	32
10287 12f651e29f6b 6843347: Boundary values in some public GC options cause crashes tschatzl parents: 10179 diff changeset	33 uint MarkSweep::_total_invocations = 0;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	34
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 2426 diff changeset	35 Stack<oop, mtGC> MarkSweep::_marking_stack;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 2426 diff changeset	36 Stack<ObjArrayTask, mtGC> MarkSweep::_objarray_stack;
0 a61af66fc99e Initial load duke parents: diff changeset	37
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 2426 diff changeset	38 Stack<oop, mtGC> MarkSweep::_preserved_oop_stack;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 2426 diff changeset	39 Stack<markOop, mtGC> MarkSweep::_preserved_mark_stack;
0 a61af66fc99e Initial load duke parents: diff changeset	40 size_t MarkSweep::_preserved_count = 0;
a61af66fc99e Initial load duke parents: diff changeset	41 size_t MarkSweep::_preserved_count_max = 0;
a61af66fc99e Initial load duke parents: diff changeset	42 PreservedMark* MarkSweep::_preserved_marks = NULL;
a61af66fc99e Initial load duke parents: diff changeset	43 ReferenceProcessor* MarkSweep::_ref_processor = NULL;
a61af66fc99e Initial load duke parents: diff changeset	44
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	45 MarkSweep::FollowRootClosure MarkSweep::follow_root_closure;
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 196 diff changeset	46 CodeBlobToOopClosure MarkSweep::follow_code_root_closure(&MarkSweep::follow_root_closure, /do_marking=/ true);
0 a61af66fc99e Initial load duke parents: diff changeset	47
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	48 void MarkSweep::FollowRootClosure::do_oop(oop* p) { follow_root(p); }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	49 void MarkSweep::FollowRootClosure::do_oop(narrowOop* p) { follow_root(p); }
0 a61af66fc99e Initial load duke parents: diff changeset	50
a61af66fc99e Initial load duke parents: diff changeset	51 MarkSweep::MarkAndPushClosure MarkSweep::mark_and_push_closure;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	52 MarkSweep::FollowKlassClosure MarkSweep::follow_klass_closure;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	53 MarkSweep::AdjustKlassClosure MarkSweep::adjust_klass_closure;
0 a61af66fc99e Initial load duke parents: diff changeset	54
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	55 void MarkSweep::MarkAndPushClosure::do_oop(oop* p) { mark_and_push(p); }
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	56 void MarkSweep::MarkAndPushClosure::do_oop(narrowOop* p) { mark_and_push(p); }
0 a61af66fc99e Initial load duke parents: diff changeset	57
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	58 void MarkSweep::FollowKlassClosure::do_klass(Klass* klass) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	59 klass->oops_do(&MarkSweep::mark_and_push_closure);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	60 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	61 void MarkSweep::AdjustKlassClosure::do_klass(Klass* klass) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	62 klass->oops_do(&MarkSweep::adjust_pointer_closure);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	63 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	64
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	65 void MarkSweep::follow_klass(Klass* klass) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	66 ClassLoaderData* cld = klass->class_loader_data();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	67 // The actual processing of the klass is done when we
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	68 // traverse the list of Klasses in the class loader data.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	69 MarkSweep::follow_class_loader(cld);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	70 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	71
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	72 void MarkSweep::adjust_klass(Klass* klass) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	73 ClassLoaderData* cld = klass->class_loader_data();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	74 // The actual processing of the klass is done when we
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	75 // traverse the list of Klasses in the class loader data.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	76 MarkSweep::adjust_class_loader(cld);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	77 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	78
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	79 void MarkSweep::follow_class_loader(ClassLoaderData* cld) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	80 cld->oops_do(&MarkSweep::mark_and_push_closure, &MarkSweep::follow_klass_closure, true);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	81 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	82
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	83 void MarkSweep::adjust_class_loader(ClassLoaderData* cld) {
10179 a08c80e9e1e5 8012687: Remove unused is_root checks and closures stefank parents: 7448 diff changeset	84 cld->oops_do(&MarkSweep::adjust_pointer_closure, &MarkSweep::adjust_klass_closure, true);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	85 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	86
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	87
0 a61af66fc99e Initial load duke parents: diff changeset	88 void MarkSweep::follow_stack() {
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1000 diff changeset	89 do {
1836 894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1552 diff changeset	90 while (!_marking_stack.is_empty()) {
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1552 diff changeset	91 oop obj = _marking_stack.pop();
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1000 diff changeset	92 assert (obj->is_gc_marked(), "p must be marked");
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1000 diff changeset	93 obj->follow_contents();
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1000 diff changeset	94 }
1315 c385bf94cfb8 6935839: excessive marking stack growth during full gcs jcoomes parents: 1311 diff changeset	95 // Process ObjArrays one at a time to avoid marking stack bloat.
1836 894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1552 diff changeset	96 if (!_objarray_stack.is_empty()) {
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1552 diff changeset	97 ObjArrayTask task = _objarray_stack.pop();
10265 92ef81e2f571 8003557: NPG: Klass* const k should be const Klass* k. minqi parents: 10179 diff changeset	98 ObjArrayKlass* k = (ObjArrayKlass*)task.obj()->klass();
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1000 diff changeset	99 k->oop_follow_contents(task.obj(), task.index());
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1000 diff changeset	100 }
1836 894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1552 diff changeset	101 } while (!_marking_stack.is_empty() \|\| !_objarray_stack.is_empty());
0 a61af66fc99e Initial load duke parents: diff changeset	102 }
a61af66fc99e Initial load duke parents: diff changeset	103
a61af66fc99e Initial load duke parents: diff changeset	104 MarkSweep::FollowStackClosure MarkSweep::follow_stack_closure;
a61af66fc99e Initial load duke parents: diff changeset	105
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	106 void MarkSweep::FollowStackClosure::do_void() { follow_stack(); }
0 a61af66fc99e Initial load duke parents: diff changeset	107
1836 894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1552 diff changeset	108 // We preserve the mark which should be replaced at the end and the location
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1552 diff changeset	109 // that it will go. Note that the object that this markOop belongs to isn't
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1552 diff changeset	110 // currently at that address but it will be after phase4
0 a61af66fc99e Initial load duke parents: diff changeset	111 void MarkSweep::preserve_mark(oop obj, markOop mark) {
1836 894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1552 diff changeset	112 // We try to store preserved marks in the to space of the new generation since
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1552 diff changeset	113 // this is storage which should be available. Most of the time this should be
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1552 diff changeset	114 // sufficient space for the marks we need to preserve but if it isn't we fall
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1552 diff changeset	115 // back to using Stacks to keep track of the overflow.
0 a61af66fc99e Initial load duke parents: diff changeset	116 if (_preserved_count < _preserved_count_max) {
a61af66fc99e Initial load duke parents: diff changeset	117 _preserved_marks[_preserved_count++].init(obj, mark);
a61af66fc99e Initial load duke parents: diff changeset	118 } else {
1836 894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1552 diff changeset	119 _preserved_mark_stack.push(mark);
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1552 diff changeset	120 _preserved_oop_stack.push(obj);
0 a61af66fc99e Initial load duke parents: diff changeset	121 }
a61af66fc99e Initial load duke parents: diff changeset	122 }
a61af66fc99e Initial load duke parents: diff changeset	123
10179 a08c80e9e1e5 8012687: Remove unused is_root checks and closures stefank parents: 7448 diff changeset	124 MarkSweep::AdjustPointerClosure MarkSweep::adjust_pointer_closure;
0 a61af66fc99e Initial load duke parents: diff changeset	125
10179 a08c80e9e1e5 8012687: Remove unused is_root checks and closures stefank parents: 7448 diff changeset	126 void MarkSweep::AdjustPointerClosure::do_oop(oop* p) { adjust_pointer(p); }
a08c80e9e1e5 8012687: Remove unused is_root checks and closures stefank parents: 7448 diff changeset	127 void MarkSweep::AdjustPointerClosure::do_oop(narrowOop* p) { adjust_pointer(p); }
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	128
0 a61af66fc99e Initial load duke parents: diff changeset	129 void MarkSweep::adjust_marks() {
1836 894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1552 diff changeset	130 assert( _preserved_oop_stack.size() == _preserved_mark_stack.size(),
0 a61af66fc99e Initial load duke parents: diff changeset	131 "inconsistent preserved oop stacks");
a61af66fc99e Initial load duke parents: diff changeset	132
a61af66fc99e Initial load duke parents: diff changeset	133 // adjust the oops we saved earlier
a61af66fc99e Initial load duke parents: diff changeset	134 for (size_t i = 0; i < _preserved_count; i++) {
a61af66fc99e Initial load duke parents: diff changeset	135 _preserved_marks[i].adjust_pointer();
a61af66fc99e Initial load duke parents: diff changeset	136 }
a61af66fc99e Initial load duke parents: diff changeset	137
a61af66fc99e Initial load duke parents: diff changeset	138 // deal with the overflow stack
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 2426 diff changeset	139 StackIterator<oop, mtGC> iter(_preserved_oop_stack);
1836 894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1552 diff changeset	140 while (!iter.is_empty()) {
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1552 diff changeset	141 oop* p = iter.next_addr();
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1552 diff changeset	142 adjust_pointer(p);
0 a61af66fc99e Initial load duke parents: diff changeset	143 }
a61af66fc99e Initial load duke parents: diff changeset	144 }
a61af66fc99e Initial load duke parents: diff changeset	145
a61af66fc99e Initial load duke parents: diff changeset	146 void MarkSweep::restore_marks() {
1836 894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1552 diff changeset	147 assert(_preserved_oop_stack.size() == _preserved_mark_stack.size(),
0 a61af66fc99e Initial load duke parents: diff changeset	148 "inconsistent preserved oop stacks");
a61af66fc99e Initial load duke parents: diff changeset	149 if (PrintGC && Verbose) {
1836 894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1552 diff changeset	150 gclog_or_tty->print_cr("Restoring %d marks",
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1552 diff changeset	151 _preserved_count + _preserved_oop_stack.size());
0 a61af66fc99e Initial load duke parents: diff changeset	152 }
a61af66fc99e Initial load duke parents: diff changeset	153
a61af66fc99e Initial load duke parents: diff changeset	154 // restore the marks we saved earlier
a61af66fc99e Initial load duke parents: diff changeset	155 for (size_t i = 0; i < _preserved_count; i++) {
a61af66fc99e Initial load duke parents: diff changeset	156 _preserved_marks[i].restore();
a61af66fc99e Initial load duke parents: diff changeset	157 }
a61af66fc99e Initial load duke parents: diff changeset	158
a61af66fc99e Initial load duke parents: diff changeset	159 // deal with the overflow
1836 894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1552 diff changeset	160 while (!_preserved_oop_stack.is_empty()) {
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1552 diff changeset	161 oop obj = _preserved_oop_stack.pop();
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1552 diff changeset	162 markOop mark = _preserved_mark_stack.pop();
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1552 diff changeset	163 obj->set_mark(mark);
0 a61af66fc99e Initial load duke parents: diff changeset	164 }
a61af66fc99e Initial load duke parents: diff changeset	165 }
a61af66fc99e Initial load duke parents: diff changeset	166
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	167 MarkSweep::IsAliveClosure MarkSweep::is_alive;
0 a61af66fc99e Initial load duke parents: diff changeset	168
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	169 bool MarkSweep::IsAliveClosure::do_object_b(oop p) { return p->is_gc_marked(); }
0 a61af66fc99e Initial load duke parents: diff changeset	170
a61af66fc99e Initial load duke parents: diff changeset	171 MarkSweep::KeepAliveClosure MarkSweep::keep_alive;
a61af66fc99e Initial load duke parents: diff changeset	172
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	173 void MarkSweep::KeepAliveClosure::do_oop(oop* p) { MarkSweep::KeepAliveClosure::do_oop_work(p); }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	174 void MarkSweep::KeepAliveClosure::do_oop(narrowOop* p) { MarkSweep::KeepAliveClosure::do_oop_work(p); }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	175
0 a61af66fc99e Initial load duke parents: diff changeset	176 void marksweep_init() { /* empty */ }
a61af66fc99e Initial load duke parents: diff changeset	177
a61af66fc99e Initial load duke parents: diff changeset	178 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	179
a61af66fc99e Initial load duke parents: diff changeset	180 void MarkSweep::trace(const char* msg) {
a61af66fc99e Initial load duke parents: diff changeset	181 if (TraceMarkSweep)
a61af66fc99e Initial load duke parents: diff changeset	182 gclog_or_tty->print("%s", msg);
a61af66fc99e Initial load duke parents: diff changeset	183 }
a61af66fc99e Initial load duke parents: diff changeset	184
a61af66fc99e Initial load duke parents: diff changeset	185 #endif

Mercurial > hg > graal-jvmci-8

annotate src/share/vm/gc_implementation/shared/markSweep.cpp @ 10374:87c64c0438fb