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

annotate src/share/vm/gc_implementation/shared/markSweep.cpp @ 10287:12f651e29f6b

6843347: Boundary values in some public GC options cause crashes Summary: Setting some public integer options to specific values causes crashes or undefined GC behavior. This patchset adds the necessary argument checking for these options. Reviewed-by: jmasa, brutisso

author	tschatzl
date	Wed, 15 May 2013 11:05:09 +0200
parents	a08c80e9e1e5
children	2958af1d8c5a 001ec9515f84

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 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();
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6757 diff changeset	98 ObjArrayKlass* const 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 void MarkSweep::IsAliveClosure::do_object(oop p) { ShouldNotReachHere(); }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	170 bool MarkSweep::IsAliveClosure::do_object_b(oop p) { return p->is_gc_marked(); }
0 a61af66fc99e Initial load duke parents: diff changeset	171
a61af66fc99e Initial load duke parents: diff changeset	172 MarkSweep::KeepAliveClosure MarkSweep::keep_alive;
a61af66fc99e Initial load duke parents: diff changeset	173
113 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(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	175 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	176
0 a61af66fc99e Initial load duke parents: diff changeset	177 void marksweep_init() { /* empty */ }
a61af66fc99e Initial load duke parents: diff changeset	178
a61af66fc99e Initial load duke parents: diff changeset	179 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	180
a61af66fc99e Initial load duke parents: diff changeset	181 void MarkSweep::trace(const char* msg) {
a61af66fc99e Initial load duke parents: diff changeset	182 if (TraceMarkSweep)
a61af66fc99e Initial load duke parents: diff changeset	183 gclog_or_tty->print("%s", msg);
a61af66fc99e Initial load duke parents: diff changeset	184 }
a61af66fc99e Initial load duke parents: diff changeset	185
a61af66fc99e Initial load duke parents: diff changeset	186 #endif

Mercurial > hg > graal-compiler

annotate src/share/vm/gc_implementation/shared/markSweep.cpp @ 10287:12f651e29f6b