truffle: src/share/vm/gc_implementation/concurrentMarkSweep/cmsOopClosures.hpp annotate

annotate src/share/vm/gc_implementation/concurrentMarkSweep/cmsOopClosures.hpp @ 3285:49a67202bc67

7011855: G1: non-product flag to artificially grow the heap Summary: It introduces non-product cmd line parameter G1DummyRegionsPerGC which indicates how many "dummy" regions to allocate at the end of each GC. This allows the G1 heap to grow artificially and makes concurrent marking cycles more frequent irrespective of what the application that is running is doing. The dummy regions will be found totally empty during cleanup so this parameter can also be used to stress the concurrent cleanup operation. Reviewed-by: brutisso, johnc

author	tonyp
date	Tue, 19 Apr 2011 15:46:59 -0400
parents	f95d63e2154a
children	da91efe96a93

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	2 * Copyright (c) 2007, 2010, 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: 994 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 994 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: 994 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: 1552 diff changeset	25 #ifndef SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_CMSOOPCLOSURES_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	26 #define SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_CMSOOPCLOSURES_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	27
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	28 #include "memory/genOopClosures.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	29
0 a61af66fc99e Initial load duke parents: diff changeset	30 /////////////////////////////////////////////////////////////////
a61af66fc99e Initial load duke parents: diff changeset	31 // Closures used by ConcurrentMarkSweepGeneration's collector
a61af66fc99e Initial load duke parents: diff changeset	32 /////////////////////////////////////////////////////////////////
a61af66fc99e Initial load duke parents: diff changeset	33 class ConcurrentMarkSweepGeneration;
a61af66fc99e Initial load duke parents: diff changeset	34 class CMSBitMap;
a61af66fc99e Initial load duke parents: diff changeset	35 class CMSMarkStack;
a61af66fc99e Initial load duke parents: diff changeset	36 class CMSCollector;
a61af66fc99e Initial load duke parents: diff changeset	37 class MarkFromRootsClosure;
a61af66fc99e Initial load duke parents: diff changeset	38 class Par_MarkFromRootsClosure;
a61af66fc99e Initial load duke parents: diff changeset	39
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	40 // Decode the oop and call do_oop on it.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	41 #define DO_OOP_WORK_DEFN \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	42 void do_oop(oop obj); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	43 template <class T> inline void do_oop_work(T* p) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	44 T heap_oop = oopDesc::load_heap_oop(p); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	45 if (!oopDesc::is_null(heap_oop)) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	46 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	47 do_oop(obj); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	48 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	49 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	50
0 a61af66fc99e Initial load duke parents: diff changeset	51 class MarkRefsIntoClosure: public OopsInGenClosure {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	52 private:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	53 const MemRegion _span;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	54 CMSBitMap* _bitMap;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	55 protected:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	56 DO_OOP_WORK_DEFN
0 a61af66fc99e Initial load duke parents: diff changeset	57 public:
994 753cf9794df9 6885169: merge of 4957990 and 6863023 causes conflict on do_nmethods jrose parents: 993 diff changeset	58 MarkRefsIntoClosure(MemRegion span, CMSBitMap* bitMap);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	59 virtual void do_oop(oop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	60 virtual void do_oop(narrowOop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	61 inline void do_oop_nv(oop* p) { MarkRefsIntoClosure::do_oop_work(p); }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	62 inline void do_oop_nv(narrowOop* p) { MarkRefsIntoClosure::do_oop_work(p); }
0 a61af66fc99e Initial load duke parents: diff changeset	63 bool do_header() { return true; }
a61af66fc99e Initial load duke parents: diff changeset	64 Prefetch::style prefetch_style() {
a61af66fc99e Initial load duke parents: diff changeset	65 return Prefetch::do_read;
a61af66fc99e Initial load duke parents: diff changeset	66 }
a61af66fc99e Initial load duke parents: diff changeset	67 };
a61af66fc99e Initial load duke parents: diff changeset	68
a61af66fc99e Initial load duke parents: diff changeset	69 // A variant of the above used in certain kinds of CMS
a61af66fc99e Initial load duke parents: diff changeset	70 // marking verification.
a61af66fc99e Initial load duke parents: diff changeset	71 class MarkRefsIntoVerifyClosure: public OopsInGenClosure {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	72 private:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	73 const MemRegion _span;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	74 CMSBitMap* _verification_bm;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	75 CMSBitMap* _cms_bm;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	76 protected:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	77 DO_OOP_WORK_DEFN
0 a61af66fc99e Initial load duke parents: diff changeset	78 public:
a61af66fc99e Initial load duke parents: diff changeset	79 MarkRefsIntoVerifyClosure(MemRegion span, CMSBitMap* verification_bm,
994 753cf9794df9 6885169: merge of 4957990 and 6863023 causes conflict on do_nmethods jrose parents: 993 diff changeset	80 CMSBitMap* cms_bm);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	81 virtual void do_oop(oop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	82 virtual void do_oop(narrowOop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	83 inline void do_oop_nv(oop* p) { MarkRefsIntoVerifyClosure::do_oop_work(p); }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	84 inline void do_oop_nv(narrowOop* p) { MarkRefsIntoVerifyClosure::do_oop_work(p); }
0 a61af66fc99e Initial load duke parents: diff changeset	85 bool do_header() { return true; }
a61af66fc99e Initial load duke parents: diff changeset	86 Prefetch::style prefetch_style() {
a61af66fc99e Initial load duke parents: diff changeset	87 return Prefetch::do_read;
a61af66fc99e Initial load duke parents: diff changeset	88 }
a61af66fc99e Initial load duke parents: diff changeset	89 };
a61af66fc99e Initial load duke parents: diff changeset	90
935 05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	91 // KlassRememberingOopClosure is used when marking of the permanent generation
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	92 // is being done. It adds fields to support revisiting of klasses
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	93 // for class unloading. _should_remember_klasses should be set to
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	94 // indicate if klasses should be remembered. Currently that is whenever
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	95 // CMS class unloading is turned on. The _revisit_stack is used
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	96 // to save the klasses for later processing.
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	97 class KlassRememberingOopClosure : public OopClosure {
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	98 protected:
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	99 CMSCollector* _collector;
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	100 CMSMarkStack* _revisit_stack;
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	101 bool const _should_remember_klasses;
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	102 public:
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	103 void check_remember_klasses() const PRODUCT_RETURN;
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	104 virtual const bool should_remember_klasses() const {
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	105 check_remember_klasses();
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	106 return _should_remember_klasses;
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	107 }
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	108 virtual void remember_klass(Klass* k);
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	109
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	110 KlassRememberingOopClosure(CMSCollector* collector,
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	111 ReferenceProcessor* rp,
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	112 CMSMarkStack* revisit_stack);
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	113 };
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	114
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	115 // Similar to KlassRememberingOopClosure for use when multiple
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	116 // GC threads will execute the closure.
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	117
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	118 class Par_KlassRememberingOopClosure : public KlassRememberingOopClosure {
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	119 public:
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	120 Par_KlassRememberingOopClosure(CMSCollector* collector,
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	121 ReferenceProcessor* rp,
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	122 CMSMarkStack* revisit_stack):
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	123 KlassRememberingOopClosure(collector, rp, revisit_stack) {}
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	124 virtual void remember_klass(Klass* k);
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	125 };
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	126
0 a61af66fc99e Initial load duke parents: diff changeset	127 // The non-parallel version (the parallel version appears further below).
935 05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	128 class PushAndMarkClosure: public KlassRememberingOopClosure {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	129 private:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	130 MemRegion _span;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	131 CMSBitMap* _bit_map;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	132 CMSBitMap* _mod_union_table;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	133 CMSMarkStack* _mark_stack;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	134 bool _concurrent_precleaning;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	135 protected:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	136 DO_OOP_WORK_DEFN
0 a61af66fc99e Initial load duke parents: diff changeset	137 public:
a61af66fc99e Initial load duke parents: diff changeset	138 PushAndMarkClosure(CMSCollector* collector,
a61af66fc99e Initial load duke parents: diff changeset	139 MemRegion span,
a61af66fc99e Initial load duke parents: diff changeset	140 ReferenceProcessor* rp,
a61af66fc99e Initial load duke parents: diff changeset	141 CMSBitMap* bit_map,
a61af66fc99e Initial load duke parents: diff changeset	142 CMSBitMap* mod_union_table,
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	143 CMSMarkStack* mark_stack,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	144 CMSMarkStack* revisit_stack,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	145 bool concurrent_precleaning);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	146 virtual void do_oop(oop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	147 virtual void do_oop(narrowOop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	148 inline void do_oop_nv(oop* p) { PushAndMarkClosure::do_oop_work(p); }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	149 inline void do_oop_nv(narrowOop* p) { PushAndMarkClosure::do_oop_work(p); }
0 a61af66fc99e Initial load duke parents: diff changeset	150 bool do_header() { return true; }
a61af66fc99e Initial load duke parents: diff changeset	151 Prefetch::style prefetch_style() {
a61af66fc99e Initial load duke parents: diff changeset	152 return Prefetch::do_read;
a61af66fc99e Initial load duke parents: diff changeset	153 }
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 935 diff changeset	154 // In support of class unloading
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 935 diff changeset	155 virtual const bool should_remember_mdo() const {
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 935 diff changeset	156 return false;
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 935 diff changeset	157 // return _should_remember_klasses;
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 935 diff changeset	158 }
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 935 diff changeset	159 virtual void remember_mdo(DataLayout* v);
0 a61af66fc99e Initial load duke parents: diff changeset	160 };
a61af66fc99e Initial load duke parents: diff changeset	161
a61af66fc99e Initial load duke parents: diff changeset	162 // In the parallel case, the revisit stack, the bit map and the
a61af66fc99e Initial load duke parents: diff changeset	163 // reference processor are currently all shared. Access to
a61af66fc99e Initial load duke parents: diff changeset	164 // these shared mutable structures must use appropriate
a61af66fc99e Initial load duke parents: diff changeset	165 // synchronization (for instance, via CAS). The marking stack
a61af66fc99e Initial load duke parents: diff changeset	166 // used in the non-parallel case above is here replaced with
a61af66fc99e Initial load duke parents: diff changeset	167 // an OopTaskQueue structure to allow efficient work stealing.
935 05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	168 class Par_PushAndMarkClosure: public Par_KlassRememberingOopClosure {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	169 private:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	170 MemRegion _span;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	171 CMSBitMap* _bit_map;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	172 OopTaskQueue* _work_queue;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	173 protected:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	174 DO_OOP_WORK_DEFN
0 a61af66fc99e Initial load duke parents: diff changeset	175 public:
a61af66fc99e Initial load duke parents: diff changeset	176 Par_PushAndMarkClosure(CMSCollector* collector,
a61af66fc99e Initial load duke parents: diff changeset	177 MemRegion span,
a61af66fc99e Initial load duke parents: diff changeset	178 ReferenceProcessor* rp,
a61af66fc99e Initial load duke parents: diff changeset	179 CMSBitMap* bit_map,
a61af66fc99e Initial load duke parents: diff changeset	180 OopTaskQueue* work_queue,
a61af66fc99e Initial load duke parents: diff changeset	181 CMSMarkStack* revisit_stack);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	182 virtual void do_oop(oop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	183 virtual void do_oop(narrowOop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	184 inline void do_oop_nv(oop* p) { Par_PushAndMarkClosure::do_oop_work(p); }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	185 inline void do_oop_nv(narrowOop* p) { Par_PushAndMarkClosure::do_oop_work(p); }
0 a61af66fc99e Initial load duke parents: diff changeset	186 bool do_header() { return true; }
a61af66fc99e Initial load duke parents: diff changeset	187 Prefetch::style prefetch_style() {
a61af66fc99e Initial load duke parents: diff changeset	188 return Prefetch::do_read;
a61af66fc99e Initial load duke parents: diff changeset	189 }
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 935 diff changeset	190 // In support of class unloading
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 935 diff changeset	191 virtual const bool should_remember_mdo() const {
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 935 diff changeset	192 return false;
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 935 diff changeset	193 // return _should_remember_klasses;
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 935 diff changeset	194 }
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 935 diff changeset	195 virtual void remember_mdo(DataLayout* v);
0 a61af66fc99e Initial load duke parents: diff changeset	196 };
a61af66fc99e Initial load duke parents: diff changeset	197
a61af66fc99e Initial load duke parents: diff changeset	198 // The non-parallel version (the parallel version appears further below).
a61af66fc99e Initial load duke parents: diff changeset	199 class MarkRefsIntoAndScanClosure: public OopsInGenClosure {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	200 private:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	201 MemRegion _span;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	202 CMSBitMap* _bit_map;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	203 CMSMarkStack* _mark_stack;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	204 PushAndMarkClosure _pushAndMarkClosure;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	205 CMSCollector* _collector;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	206 Mutex* _freelistLock;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	207 bool _yield;
0 a61af66fc99e Initial load duke parents: diff changeset	208 // Whether closure is being used for concurrent precleaning
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	209 bool _concurrent_precleaning;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	210 protected:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	211 DO_OOP_WORK_DEFN
0 a61af66fc99e Initial load duke parents: diff changeset	212 public:
a61af66fc99e Initial load duke parents: diff changeset	213 MarkRefsIntoAndScanClosure(MemRegion span,
a61af66fc99e Initial load duke parents: diff changeset	214 ReferenceProcessor* rp,
a61af66fc99e Initial load duke parents: diff changeset	215 CMSBitMap* bit_map,
a61af66fc99e Initial load duke parents: diff changeset	216 CMSBitMap* mod_union_table,
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	217 CMSMarkStack* mark_stack,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	218 CMSMarkStack* revisit_stack,
0 a61af66fc99e Initial load duke parents: diff changeset	219 CMSCollector* collector,
a61af66fc99e Initial load duke parents: diff changeset	220 bool should_yield,
a61af66fc99e Initial load duke parents: diff changeset	221 bool concurrent_precleaning);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	222 virtual void do_oop(oop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	223 virtual void do_oop(narrowOop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	224 inline void do_oop_nv(oop* p) { MarkRefsIntoAndScanClosure::do_oop_work(p); }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	225 inline void do_oop_nv(narrowOop* p) { MarkRefsIntoAndScanClosure::do_oop_work(p); }
0 a61af66fc99e Initial load duke parents: diff changeset	226 bool do_header() { return true; }
a61af66fc99e Initial load duke parents: diff changeset	227 Prefetch::style prefetch_style() {
a61af66fc99e Initial load duke parents: diff changeset	228 return Prefetch::do_read;
a61af66fc99e Initial load duke parents: diff changeset	229 }
a61af66fc99e Initial load duke parents: diff changeset	230 void set_freelistLock(Mutex* m) {
a61af66fc99e Initial load duke parents: diff changeset	231 _freelistLock = m;
a61af66fc99e Initial load duke parents: diff changeset	232 }
935 05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	233 virtual const bool should_remember_klasses() const {
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	234 return _pushAndMarkClosure.should_remember_klasses();
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	235 }
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	236 virtual void remember_klass(Klass* k) {
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	237 _pushAndMarkClosure.remember_klass(k);
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	238 }
0 a61af66fc99e Initial load duke parents: diff changeset	239
a61af66fc99e Initial load duke parents: diff changeset	240 private:
a61af66fc99e Initial load duke parents: diff changeset	241 inline void do_yield_check();
a61af66fc99e Initial load duke parents: diff changeset	242 void do_yield_work();
a61af66fc99e Initial load duke parents: diff changeset	243 bool take_from_overflow_list();
a61af66fc99e Initial load duke parents: diff changeset	244 };
a61af66fc99e Initial load duke parents: diff changeset	245
a61af66fc99e Initial load duke parents: diff changeset	246 // Tn this, the parallel avatar of MarkRefsIntoAndScanClosure, the revisit
a61af66fc99e Initial load duke parents: diff changeset	247 // stack and the bitMap are shared, so access needs to be suitably
a61af66fc99e Initial load duke parents: diff changeset	248 // sycnhronized. An OopTaskQueue structure, supporting efficient
a61af66fc99e Initial load duke parents: diff changeset	249 // workstealing, replaces a CMSMarkStack for storing grey objects.
a61af66fc99e Initial load duke parents: diff changeset	250 class Par_MarkRefsIntoAndScanClosure: public OopsInGenClosure {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	251 private:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	252 MemRegion _span;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	253 CMSBitMap* _bit_map;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	254 OopTaskQueue* _work_queue;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	255 const uint _low_water_mark;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	256 Par_PushAndMarkClosure _par_pushAndMarkClosure;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	257 protected:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	258 DO_OOP_WORK_DEFN
0 a61af66fc99e Initial load duke parents: diff changeset	259 public:
a61af66fc99e Initial load duke parents: diff changeset	260 Par_MarkRefsIntoAndScanClosure(CMSCollector* collector,
a61af66fc99e Initial load duke parents: diff changeset	261 MemRegion span,
a61af66fc99e Initial load duke parents: diff changeset	262 ReferenceProcessor* rp,
a61af66fc99e Initial load duke parents: diff changeset	263 CMSBitMap* bit_map,
a61af66fc99e Initial load duke parents: diff changeset	264 OopTaskQueue* work_queue,
a61af66fc99e Initial load duke parents: diff changeset	265 CMSMarkStack* revisit_stack);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	266 virtual void do_oop(oop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	267 virtual void do_oop(narrowOop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	268 inline void do_oop_nv(oop* p) { Par_MarkRefsIntoAndScanClosure::do_oop_work(p); }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	269 inline void do_oop_nv(narrowOop* p) { Par_MarkRefsIntoAndScanClosure::do_oop_work(p); }
0 a61af66fc99e Initial load duke parents: diff changeset	270 bool do_header() { return true; }
935 05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	271 // When ScanMarkedObjectsAgainClosure is used,
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	272 // it passes [Par_]MarkRefsIntoAndScanClosure to oop_oop_iterate(),
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	273 // and this delegation is used.
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	274 virtual const bool should_remember_klasses() const {
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	275 return _par_pushAndMarkClosure.should_remember_klasses();
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	276 }
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	277 // See comment on should_remember_klasses() above.
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	278 virtual void remember_klass(Klass* k) {
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	279 _par_pushAndMarkClosure.remember_klass(k);
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	280 }
0 a61af66fc99e Initial load duke parents: diff changeset	281 Prefetch::style prefetch_style() {
a61af66fc99e Initial load duke parents: diff changeset	282 return Prefetch::do_read;
a61af66fc99e Initial load duke parents: diff changeset	283 }
a61af66fc99e Initial load duke parents: diff changeset	284 void trim_queue(uint size);
a61af66fc99e Initial load duke parents: diff changeset	285 };
a61af66fc99e Initial load duke parents: diff changeset	286
a61af66fc99e Initial load duke parents: diff changeset	287 // This closure is used during the concurrent marking phase
a61af66fc99e Initial load duke parents: diff changeset	288 // following the first checkpoint. Its use is buried in
a61af66fc99e Initial load duke parents: diff changeset	289 // the closure MarkFromRootsClosure.
935 05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	290 class PushOrMarkClosure: public KlassRememberingOopClosure {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	291 private:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	292 MemRegion _span;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	293 CMSBitMap* _bitMap;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	294 CMSMarkStack* _markStack;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	295 HeapWord* const _finger;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	296 MarkFromRootsClosure* const
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	297 _parent;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	298 protected:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	299 DO_OOP_WORK_DEFN
0 a61af66fc99e Initial load duke parents: diff changeset	300 public:
a61af66fc99e Initial load duke parents: diff changeset	301 PushOrMarkClosure(CMSCollector* cms_collector,
a61af66fc99e Initial load duke parents: diff changeset	302 MemRegion span,
a61af66fc99e Initial load duke parents: diff changeset	303 CMSBitMap* bitMap,
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	304 CMSMarkStack* markStack,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	305 CMSMarkStack* revisitStack,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	306 HeapWord* finger,
0 a61af66fc99e Initial load duke parents: diff changeset	307 MarkFromRootsClosure* parent);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	308 virtual void do_oop(oop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	309 virtual void do_oop(narrowOop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	310 inline void do_oop_nv(oop* p) { PushOrMarkClosure::do_oop_work(p); }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	311 inline void do_oop_nv(narrowOop* p) { PushOrMarkClosure::do_oop_work(p); }
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 935 diff changeset	312 // In support of class unloading
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 935 diff changeset	313 virtual const bool should_remember_mdo() const {
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 935 diff changeset	314 return false;
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 935 diff changeset	315 // return _should_remember_klasses;
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 935 diff changeset	316 }
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 935 diff changeset	317 virtual void remember_mdo(DataLayout* v);
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 935 diff changeset	318
0 a61af66fc99e Initial load duke parents: diff changeset	319 // Deal with a stack overflow condition
a61af66fc99e Initial load duke parents: diff changeset	320 void handle_stack_overflow(HeapWord* lost);
a61af66fc99e Initial load duke parents: diff changeset	321 private:
a61af66fc99e Initial load duke parents: diff changeset	322 inline void do_yield_check();
a61af66fc99e Initial load duke parents: diff changeset	323 };
a61af66fc99e Initial load duke parents: diff changeset	324
a61af66fc99e Initial load duke parents: diff changeset	325 // A parallel (MT) version of the above.
a61af66fc99e Initial load duke parents: diff changeset	326 // This closure is used during the concurrent marking phase
a61af66fc99e Initial load duke parents: diff changeset	327 // following the first checkpoint. Its use is buried in
a61af66fc99e Initial load duke parents: diff changeset	328 // the closure Par_MarkFromRootsClosure.
935 05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	329 class Par_PushOrMarkClosure: public Par_KlassRememberingOopClosure {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	330 private:
0 a61af66fc99e Initial load duke parents: diff changeset	331 MemRegion _whole_span;
a61af66fc99e Initial load duke parents: diff changeset	332 MemRegion _span; // local chunk
a61af66fc99e Initial load duke parents: diff changeset	333 CMSBitMap* _bit_map;
a61af66fc99e Initial load duke parents: diff changeset	334 OopTaskQueue* _work_queue;
a61af66fc99e Initial load duke parents: diff changeset	335 CMSMarkStack* _overflow_stack;
a61af66fc99e Initial load duke parents: diff changeset	336 HeapWord* const _finger;
a61af66fc99e Initial load duke parents: diff changeset	337 HeapWord** const _global_finger_addr;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	338 Par_MarkFromRootsClosure* const
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	339 _parent;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	340 protected:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	341 DO_OOP_WORK_DEFN
0 a61af66fc99e Initial load duke parents: diff changeset	342 public:
a61af66fc99e Initial load duke parents: diff changeset	343 Par_PushOrMarkClosure(CMSCollector* cms_collector,
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	344 MemRegion span,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	345 CMSBitMap* bit_map,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	346 OopTaskQueue* work_queue,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	347 CMSMarkStack* mark_stack,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	348 CMSMarkStack* revisit_stack,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	349 HeapWord* finger,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	350 HeapWord** global_finger_addr,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	351 Par_MarkFromRootsClosure* parent);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	352 virtual void do_oop(oop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	353 virtual void do_oop(narrowOop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	354 inline void do_oop_nv(oop* p) { Par_PushOrMarkClosure::do_oop_work(p); }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	355 inline void do_oop_nv(narrowOop* p) { Par_PushOrMarkClosure::do_oop_work(p); }
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 935 diff changeset	356 // In support of class unloading
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 935 diff changeset	357 virtual const bool should_remember_mdo() const {
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 935 diff changeset	358 return false;
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 935 diff changeset	359 // return _should_remember_klasses;
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 935 diff changeset	360 }
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 935 diff changeset	361 virtual void remember_mdo(DataLayout* v);
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 935 diff changeset	362
0 a61af66fc99e Initial load duke parents: diff changeset	363 // Deal with a stack overflow condition
a61af66fc99e Initial load duke parents: diff changeset	364 void handle_stack_overflow(HeapWord* lost);
a61af66fc99e Initial load duke parents: diff changeset	365 private:
a61af66fc99e Initial load duke parents: diff changeset	366 inline void do_yield_check();
a61af66fc99e Initial load duke parents: diff changeset	367 };
a61af66fc99e Initial load duke parents: diff changeset	368
a61af66fc99e Initial load duke parents: diff changeset	369 // For objects in CMS generation, this closure marks
a61af66fc99e Initial load duke parents: diff changeset	370 // given objects (transitively) as being reachable/live.
a61af66fc99e Initial load duke parents: diff changeset	371 // This is currently used during the (weak) reference object
452 00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 143 diff changeset	372 // processing phase of the CMS final checkpoint step, as
00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 143 diff changeset	373 // well as during the concurrent precleaning of the discovered
00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 143 diff changeset	374 // reference lists.
935 05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	375 class CMSKeepAliveClosure: public KlassRememberingOopClosure {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	376 private:
143 b5489bb705c9 6662086: 6u4+, 7b11+: CMS never clears referents when -XX:+ParallelRefProcEnabled ysr parents: 113 diff changeset	377 const MemRegion _span;
0 a61af66fc99e Initial load duke parents: diff changeset	378 CMSMarkStack* _mark_stack;
a61af66fc99e Initial load duke parents: diff changeset	379 CMSBitMap* _bit_map;
452 00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 143 diff changeset	380 bool _concurrent_precleaning;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	381 protected:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	382 DO_OOP_WORK_DEFN
0 a61af66fc99e Initial load duke parents: diff changeset	383 public:
a61af66fc99e Initial load duke parents: diff changeset	384 CMSKeepAliveClosure(CMSCollector* collector, MemRegion span,
452 00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 143 diff changeset	385 CMSBitMap* bit_map, CMSMarkStack* mark_stack,
935 05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	386 CMSMarkStack* revisit_stack, bool cpc);
452 00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 143 diff changeset	387 bool concurrent_precleaning() const { return _concurrent_precleaning; }
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	388 virtual void do_oop(oop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	389 virtual void do_oop(narrowOop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	390 inline void do_oop_nv(oop* p) { CMSKeepAliveClosure::do_oop_work(p); }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	391 inline void do_oop_nv(narrowOop* p) { CMSKeepAliveClosure::do_oop_work(p); }
0 a61af66fc99e Initial load duke parents: diff changeset	392 };
a61af66fc99e Initial load duke parents: diff changeset	393
935 05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	394 class CMSInnerParMarkAndPushClosure: public Par_KlassRememberingOopClosure {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	395 private:
0 a61af66fc99e Initial load duke parents: diff changeset	396 MemRegion _span;
a61af66fc99e Initial load duke parents: diff changeset	397 OopTaskQueue* _work_queue;
a61af66fc99e Initial load duke parents: diff changeset	398 CMSBitMap* _bit_map;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	399 protected:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	400 DO_OOP_WORK_DEFN
0 a61af66fc99e Initial load duke parents: diff changeset	401 public:
a61af66fc99e Initial load duke parents: diff changeset	402 CMSInnerParMarkAndPushClosure(CMSCollector* collector,
a61af66fc99e Initial load duke parents: diff changeset	403 MemRegion span, CMSBitMap* bit_map,
935 05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	404 CMSMarkStack* revisit_stack,
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	405 OopTaskQueue* work_queue);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	406 virtual void do_oop(oop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	407 virtual void do_oop(narrowOop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	408 inline void do_oop_nv(oop* p) { CMSInnerParMarkAndPushClosure::do_oop_work(p); }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	409 inline void do_oop_nv(narrowOop* p) { CMSInnerParMarkAndPushClosure::do_oop_work(p); }
0 a61af66fc99e Initial load duke parents: diff changeset	410 };
a61af66fc99e Initial load duke parents: diff changeset	411
a61af66fc99e Initial load duke parents: diff changeset	412 // A parallel (MT) version of the above, used when
a61af66fc99e Initial load duke parents: diff changeset	413 // reference processing is parallel; the only difference
a61af66fc99e Initial load duke parents: diff changeset	414 // is in the do_oop method.
935 05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	415 class CMSParKeepAliveClosure: public Par_KlassRememberingOopClosure {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	416 private:
0 a61af66fc99e Initial load duke parents: diff changeset	417 MemRegion _span;
a61af66fc99e Initial load duke parents: diff changeset	418 OopTaskQueue* _work_queue;
a61af66fc99e Initial load duke parents: diff changeset	419 CMSBitMap* _bit_map;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	420 CMSInnerParMarkAndPushClosure
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	421 _mark_and_push;
0 a61af66fc99e Initial load duke parents: diff changeset	422 const uint _low_water_mark;
a61af66fc99e Initial load duke parents: diff changeset	423 void trim_queue(uint max);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	424 protected:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	425 DO_OOP_WORK_DEFN
0 a61af66fc99e Initial load duke parents: diff changeset	426 public:
a61af66fc99e Initial load duke parents: diff changeset	427 CMSParKeepAliveClosure(CMSCollector* collector, MemRegion span,
935 05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	428 CMSBitMap* bit_map, CMSMarkStack* revisit_stack,
05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	429 OopTaskQueue* work_queue);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	430 virtual void do_oop(oop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	431 virtual void do_oop(narrowOop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	432 inline void do_oop_nv(oop* p) { CMSParKeepAliveClosure::do_oop_work(p); }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	433 inline void do_oop_nv(narrowOop* p) { CMSParKeepAliveClosure::do_oop_work(p); }
0 a61af66fc99e Initial load duke parents: diff changeset	434 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	435
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	436 #endif // SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_CMSOOPCLOSURES_HPP

Mercurial > hg > truffle

annotate src/share/vm/gc_implementation/concurrentMarkSweep/cmsOopClosures.hpp @ 3285:49a67202bc67