graal-compiler: src/share/vm/gc_implementation/concurrentMarkSweep/cmsOopClosures.hpp annotate

annotate src/share/vm/gc_implementation/concurrentMarkSweep/cmsOopClosures.hpp @ 10185:d50cc62e94ff

8012715: G1: GraphKit accesses PtrQueue::_index as int but is size_t Summary: In graphKit INT operations were generated to access PtrQueue::_index which has type size_t. This is 64 bit on 64-bit machines. No problems occur on little endian machines as long as the index fits into 32 bit, but on big endian machines the upper part is read, which is zero. This leads to unnecessary branches to the slow path in the runtime. Reviewed-by: twisti, johnc Contributed-by: Martin Doerr <martin.doerr@sap.com>

author	johnc
date	Wed, 24 Apr 2013 14:48:43 -0700
parents	da91efe96a93
children	ca9dedeebdec

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: 1972 diff changeset	2 * Copyright (c) 2007, 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: 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
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	51 // Applies the given oop closure to all oops in all klasses visited.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	52 class CMKlassClosure : public KlassClosure {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	53 friend class CMSOopClosure;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	54 friend class CMSOopsInGenClosure;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	55
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	56 OopClosure* _oop_closure;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	57
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	58 // Used when _oop_closure couldn't be set in an initialization list.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	59 void initialize(OopClosure* oop_closure) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	60 assert(_oop_closure == NULL, "Should only be called once");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	61 _oop_closure = oop_closure;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	62 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	63 public:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	64 CMKlassClosure(OopClosure* oop_closure = NULL) : _oop_closure(oop_closure) { }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	65
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	66 void do_klass(Klass* k);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	67 };
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	68
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	69 // The base class for all CMS marking closures.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	70 // It's used to proxy through the metadata to the oops defined in them.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	71 class CMSOopClosure: public ExtendedOopClosure {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	72 CMKlassClosure _klass_closure;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	73 public:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	74 CMSOopClosure() : ExtendedOopClosure() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	75 _klass_closure.initialize(this);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	76 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	77 CMSOopClosure(ReferenceProcessor* rp) : ExtendedOopClosure(rp) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	78 _klass_closure.initialize(this);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	79 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	80
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	81 virtual bool do_metadata() { return do_metadata_nv(); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	82 inline bool do_metadata_nv() { return true; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	83
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	84 virtual void do_klass(Klass* k);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	85 void do_klass_nv(Klass* k);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	86
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	87 virtual void do_class_loader_data(ClassLoaderData* cld);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	88 };
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	89
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	90 // TODO: This duplication of the CMSOopClosure class is only needed because
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	91 // some CMS OopClosures derive from OopsInGenClosure. It would be good
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	92 // to get rid of them completely.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	93 class CMSOopsInGenClosure: public OopsInGenClosure {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	94 CMKlassClosure _klass_closure;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	95 public:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	96 CMSOopsInGenClosure() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	97 _klass_closure.initialize(this);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	98 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	99
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	100 virtual bool do_metadata() { return do_metadata_nv(); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	101 inline bool do_metadata_nv() { return true; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	102
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	103 virtual void do_klass(Klass* k);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	104 void do_klass_nv(Klass* k);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	105
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	106 virtual void do_class_loader_data(ClassLoaderData* cld);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	107 };
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	108
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	109 class MarkRefsIntoClosure: public CMSOopsInGenClosure {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	110 private:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	111 const MemRegion _span;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	112 CMSBitMap* _bitMap;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	113 protected:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	114 DO_OOP_WORK_DEFN
0 a61af66fc99e Initial load duke parents: diff changeset	115 public:
994 753cf9794df9 6885169: merge of 4957990 and 6863023 causes conflict on do_nmethods jrose parents: 993 diff changeset	116 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	117 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	118 virtual void do_oop(narrowOop* p);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	119
0 a61af66fc99e Initial load duke parents: diff changeset	120 Prefetch::style prefetch_style() {
a61af66fc99e Initial load duke parents: diff changeset	121 return Prefetch::do_read;
a61af66fc99e Initial load duke parents: diff changeset	122 }
a61af66fc99e Initial load duke parents: diff changeset	123 };
a61af66fc99e Initial load duke parents: diff changeset	124
a61af66fc99e Initial load duke parents: diff changeset	125 // A variant of the above used in certain kinds of CMS
a61af66fc99e Initial load duke parents: diff changeset	126 // marking verification.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	127 class MarkRefsIntoVerifyClosure: public CMSOopsInGenClosure {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	128 private:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	129 const MemRegion _span;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	130 CMSBitMap* _verification_bm;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	131 CMSBitMap* _cms_bm;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	132 protected:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	133 DO_OOP_WORK_DEFN
0 a61af66fc99e Initial load duke parents: diff changeset	134 public:
a61af66fc99e Initial load duke parents: diff changeset	135 MarkRefsIntoVerifyClosure(MemRegion span, CMSBitMap* verification_bm,
994 753cf9794df9 6885169: merge of 4957990 and 6863023 causes conflict on do_nmethods jrose parents: 993 diff changeset	136 CMSBitMap* cms_bm);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	137 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	138 virtual void do_oop(narrowOop* p);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	139
0 a61af66fc99e Initial load duke parents: diff changeset	140 Prefetch::style prefetch_style() {
a61af66fc99e Initial load duke parents: diff changeset	141 return Prefetch::do_read;
a61af66fc99e Initial load duke parents: diff changeset	142 }
a61af66fc99e Initial load duke parents: diff changeset	143 };
a61af66fc99e Initial load duke parents: diff changeset	144
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	145 // The non-parallel version (the parallel version appears further below).
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	146 class PushAndMarkClosure: public CMSOopClosure {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	147 private:
935 05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	148 CMSCollector* _collector;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	149 MemRegion _span;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	150 CMSBitMap* _bit_map;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	151 CMSBitMap* _mod_union_table;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	152 CMSMarkStack* _mark_stack;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	153 bool _concurrent_precleaning;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	154 protected:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	155 DO_OOP_WORK_DEFN
0 a61af66fc99e Initial load duke parents: diff changeset	156 public:
a61af66fc99e Initial load duke parents: diff changeset	157 PushAndMarkClosure(CMSCollector* collector,
a61af66fc99e Initial load duke parents: diff changeset	158 MemRegion span,
a61af66fc99e Initial load duke parents: diff changeset	159 ReferenceProcessor* rp,
a61af66fc99e Initial load duke parents: diff changeset	160 CMSBitMap* bit_map,
a61af66fc99e Initial load duke parents: diff changeset	161 CMSBitMap* mod_union_table,
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	162 CMSMarkStack* mark_stack,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	163 bool concurrent_precleaning);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	164 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	165 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	166 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	167 inline void do_oop_nv(narrowOop* p) { PushAndMarkClosure::do_oop_work(p); }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	168
0 a61af66fc99e Initial load duke parents: diff changeset	169 Prefetch::style prefetch_style() {
a61af66fc99e Initial load duke parents: diff changeset	170 return Prefetch::do_read;
a61af66fc99e Initial load duke parents: diff changeset	171 }
a61af66fc99e Initial load duke parents: diff changeset	172 };
a61af66fc99e Initial load duke parents: diff changeset	173
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	174 // In the parallel case, the bit map and the
0 a61af66fc99e Initial load duke parents: diff changeset	175 // reference processor are currently all shared. Access to
a61af66fc99e Initial load duke parents: diff changeset	176 // these shared mutable structures must use appropriate
a61af66fc99e Initial load duke parents: diff changeset	177 // synchronization (for instance, via CAS). The marking stack
a61af66fc99e Initial load duke parents: diff changeset	178 // used in the non-parallel case above is here replaced with
a61af66fc99e Initial load duke parents: diff changeset	179 // an OopTaskQueue structure to allow efficient work stealing.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	180 class Par_PushAndMarkClosure: public CMSOopClosure {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	181 private:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	182 CMSCollector* _collector;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	183 MemRegion _span;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	184 CMSBitMap* _bit_map;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	185 OopTaskQueue* _work_queue;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	186 protected:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	187 DO_OOP_WORK_DEFN
0 a61af66fc99e Initial load duke parents: diff changeset	188 public:
a61af66fc99e Initial load duke parents: diff changeset	189 Par_PushAndMarkClosure(CMSCollector* collector,
a61af66fc99e Initial load duke parents: diff changeset	190 MemRegion span,
a61af66fc99e Initial load duke parents: diff changeset	191 ReferenceProcessor* rp,
a61af66fc99e Initial load duke parents: diff changeset	192 CMSBitMap* bit_map,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	193 OopTaskQueue* work_queue);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	194 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	195 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	196 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	197 inline void do_oop_nv(narrowOop* p) { Par_PushAndMarkClosure::do_oop_work(p); }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	198
0 a61af66fc99e Initial load duke parents: diff changeset	199 Prefetch::style prefetch_style() {
a61af66fc99e Initial load duke parents: diff changeset	200 return Prefetch::do_read;
a61af66fc99e Initial load duke parents: diff changeset	201 }
a61af66fc99e Initial load duke parents: diff changeset	202 };
a61af66fc99e Initial load duke parents: diff changeset	203
a61af66fc99e Initial load duke parents: diff changeset	204 // The non-parallel version (the parallel version appears further below).
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	205 class MarkRefsIntoAndScanClosure: public CMSOopsInGenClosure {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	206 private:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	207 MemRegion _span;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	208 CMSBitMap* _bit_map;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	209 CMSMarkStack* _mark_stack;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	210 PushAndMarkClosure _pushAndMarkClosure;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	211 CMSCollector* _collector;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	212 Mutex* _freelistLock;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	213 bool _yield;
0 a61af66fc99e Initial load duke parents: diff changeset	214 // 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	215 bool _concurrent_precleaning;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	216 protected:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	217 DO_OOP_WORK_DEFN
0 a61af66fc99e Initial load duke parents: diff changeset	218 public:
a61af66fc99e Initial load duke parents: diff changeset	219 MarkRefsIntoAndScanClosure(MemRegion span,
a61af66fc99e Initial load duke parents: diff changeset	220 ReferenceProcessor* rp,
a61af66fc99e Initial load duke parents: diff changeset	221 CMSBitMap* bit_map,
a61af66fc99e Initial load duke parents: diff changeset	222 CMSBitMap* mod_union_table,
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	223 CMSMarkStack* mark_stack,
0 a61af66fc99e Initial load duke parents: diff changeset	224 CMSCollector* collector,
a61af66fc99e Initial load duke parents: diff changeset	225 bool should_yield,
a61af66fc99e Initial load duke parents: diff changeset	226 bool concurrent_precleaning);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	227 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	228 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	229 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	230 inline void do_oop_nv(narrowOop* p) { MarkRefsIntoAndScanClosure::do_oop_work(p); }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	231
0 a61af66fc99e Initial load duke parents: diff changeset	232 Prefetch::style prefetch_style() {
a61af66fc99e Initial load duke parents: diff changeset	233 return Prefetch::do_read;
a61af66fc99e Initial load duke parents: diff changeset	234 }
a61af66fc99e Initial load duke parents: diff changeset	235 void set_freelistLock(Mutex* m) {
a61af66fc99e Initial load duke parents: diff changeset	236 _freelistLock = m;
a61af66fc99e Initial load duke parents: diff changeset	237 }
a61af66fc99e Initial load duke parents: diff changeset	238
a61af66fc99e Initial load duke parents: diff changeset	239 private:
a61af66fc99e Initial load duke parents: diff changeset	240 inline void do_yield_check();
a61af66fc99e Initial load duke parents: diff changeset	241 void do_yield_work();
a61af66fc99e Initial load duke parents: diff changeset	242 bool take_from_overflow_list();
a61af66fc99e Initial load duke parents: diff changeset	243 };
a61af66fc99e Initial load duke parents: diff changeset	244
a61af66fc99e Initial load duke parents: diff changeset	245 // Tn this, the parallel avatar of MarkRefsIntoAndScanClosure, the revisit
a61af66fc99e Initial load duke parents: diff changeset	246 // stack and the bitMap are shared, so access needs to be suitably
a61af66fc99e Initial load duke parents: diff changeset	247 // sycnhronized. An OopTaskQueue structure, supporting efficient
a61af66fc99e Initial load duke parents: diff changeset	248 // workstealing, replaces a CMSMarkStack for storing grey objects.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	249 class Par_MarkRefsIntoAndScanClosure: public CMSOopsInGenClosure {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	250 private:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	251 MemRegion _span;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	252 CMSBitMap* _bit_map;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	253 OopTaskQueue* _work_queue;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	254 const uint _low_water_mark;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	255 Par_PushAndMarkClosure _par_pushAndMarkClosure;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	256 protected:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	257 DO_OOP_WORK_DEFN
0 a61af66fc99e Initial load duke parents: diff changeset	258 public:
a61af66fc99e Initial load duke parents: diff changeset	259 Par_MarkRefsIntoAndScanClosure(CMSCollector* collector,
a61af66fc99e Initial load duke parents: diff changeset	260 MemRegion span,
a61af66fc99e Initial load duke parents: diff changeset	261 ReferenceProcessor* rp,
a61af66fc99e Initial load duke parents: diff changeset	262 CMSBitMap* bit_map,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	263 OopTaskQueue* work_queue);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	264 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	265 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	266 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	267 inline void do_oop_nv(narrowOop* p) { Par_MarkRefsIntoAndScanClosure::do_oop_work(p); }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	268
0 a61af66fc99e Initial load duke parents: diff changeset	269 Prefetch::style prefetch_style() {
a61af66fc99e Initial load duke parents: diff changeset	270 return Prefetch::do_read;
a61af66fc99e Initial load duke parents: diff changeset	271 }
a61af66fc99e Initial load duke parents: diff changeset	272 void trim_queue(uint size);
a61af66fc99e Initial load duke parents: diff changeset	273 };
a61af66fc99e Initial load duke parents: diff changeset	274
a61af66fc99e Initial load duke parents: diff changeset	275 // This closure is used during the concurrent marking phase
a61af66fc99e Initial load duke parents: diff changeset	276 // following the first checkpoint. Its use is buried in
a61af66fc99e Initial load duke parents: diff changeset	277 // the closure MarkFromRootsClosure.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	278 class PushOrMarkClosure: public CMSOopClosure {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	279 private:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	280 CMSCollector* _collector;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	281 MemRegion _span;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	282 CMSBitMap* _bitMap;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	283 CMSMarkStack* _markStack;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	284 HeapWord* const _finger;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	285 MarkFromRootsClosure* const
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	286 _parent;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	287 protected:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	288 DO_OOP_WORK_DEFN
0 a61af66fc99e Initial load duke parents: diff changeset	289 public:
a61af66fc99e Initial load duke parents: diff changeset	290 PushOrMarkClosure(CMSCollector* cms_collector,
a61af66fc99e Initial load duke parents: diff changeset	291 MemRegion span,
a61af66fc99e Initial load duke parents: diff changeset	292 CMSBitMap* bitMap,
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	293 CMSMarkStack* markStack,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	294 HeapWord* finger,
0 a61af66fc99e Initial load duke parents: diff changeset	295 MarkFromRootsClosure* parent);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	296 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	297 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	298 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	299 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	300
0 a61af66fc99e Initial load duke parents: diff changeset	301 // Deal with a stack overflow condition
a61af66fc99e Initial load duke parents: diff changeset	302 void handle_stack_overflow(HeapWord* lost);
a61af66fc99e Initial load duke parents: diff changeset	303 private:
a61af66fc99e Initial load duke parents: diff changeset	304 inline void do_yield_check();
a61af66fc99e Initial load duke parents: diff changeset	305 };
a61af66fc99e Initial load duke parents: diff changeset	306
a61af66fc99e Initial load duke parents: diff changeset	307 // A parallel (MT) version of the above.
a61af66fc99e Initial load duke parents: diff changeset	308 // This closure is used during the concurrent marking phase
a61af66fc99e Initial load duke parents: diff changeset	309 // following the first checkpoint. Its use is buried in
a61af66fc99e Initial load duke parents: diff changeset	310 // the closure Par_MarkFromRootsClosure.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	311 class Par_PushOrMarkClosure: public CMSOopClosure {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	312 private:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	313 CMSCollector* _collector;
0 a61af66fc99e Initial load duke parents: diff changeset	314 MemRegion _whole_span;
a61af66fc99e Initial load duke parents: diff changeset	315 MemRegion _span; // local chunk
a61af66fc99e Initial load duke parents: diff changeset	316 CMSBitMap* _bit_map;
a61af66fc99e Initial load duke parents: diff changeset	317 OopTaskQueue* _work_queue;
a61af66fc99e Initial load duke parents: diff changeset	318 CMSMarkStack* _overflow_stack;
a61af66fc99e Initial load duke parents: diff changeset	319 HeapWord* const _finger;
a61af66fc99e Initial load duke parents: diff changeset	320 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	321 Par_MarkFromRootsClosure* const
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	322 _parent;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	323 protected:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	324 DO_OOP_WORK_DEFN
0 a61af66fc99e Initial load duke parents: diff changeset	325 public:
a61af66fc99e Initial load duke parents: diff changeset	326 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	327 MemRegion span,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	328 CMSBitMap* bit_map,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	329 OopTaskQueue* work_queue,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	330 CMSMarkStack* mark_stack,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	331 HeapWord* finger,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	332 HeapWord** global_finger_addr,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	333 Par_MarkFromRootsClosure* parent);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	334 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	335 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	336 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	337 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	338
0 a61af66fc99e Initial load duke parents: diff changeset	339 // Deal with a stack overflow condition
a61af66fc99e Initial load duke parents: diff changeset	340 void handle_stack_overflow(HeapWord* lost);
a61af66fc99e Initial load duke parents: diff changeset	341 private:
a61af66fc99e Initial load duke parents: diff changeset	342 inline void do_yield_check();
a61af66fc99e Initial load duke parents: diff changeset	343 };
a61af66fc99e Initial load duke parents: diff changeset	344
a61af66fc99e Initial load duke parents: diff changeset	345 // For objects in CMS generation, this closure marks
a61af66fc99e Initial load duke parents: diff changeset	346 // given objects (transitively) as being reachable/live.
a61af66fc99e Initial load duke parents: diff changeset	347 // 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	348 // 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	349 // 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	350 // reference lists.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	351 class CMSKeepAliveClosure: public CMSOopClosure {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	352 private:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	353 CMSCollector* _collector;
143 b5489bb705c9 6662086: 6u4+, 7b11+: CMS never clears referents when -XX:+ParallelRefProcEnabled ysr parents: 113 diff changeset	354 const MemRegion _span;
0 a61af66fc99e Initial load duke parents: diff changeset	355 CMSMarkStack* _mark_stack;
a61af66fc99e Initial load duke parents: diff changeset	356 CMSBitMap* _bit_map;
452 00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 143 diff changeset	357 bool _concurrent_precleaning;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	358 protected:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	359 DO_OOP_WORK_DEFN
0 a61af66fc99e Initial load duke parents: diff changeset	360 public:
a61af66fc99e Initial load duke parents: diff changeset	361 CMSKeepAliveClosure(CMSCollector* collector, MemRegion span,
452 00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 143 diff changeset	362 CMSBitMap* bit_map, CMSMarkStack* mark_stack,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	363 bool cpc);
452 00b023ae2d78 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists ysr parents: 143 diff changeset	364 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	365 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	366 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	367 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	368 inline void do_oop_nv(narrowOop* p) { CMSKeepAliveClosure::do_oop_work(p); }
0 a61af66fc99e Initial load duke parents: diff changeset	369 };
a61af66fc99e Initial load duke parents: diff changeset	370
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	371 class CMSInnerParMarkAndPushClosure: public CMSOopClosure {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	372 private:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	373 CMSCollector* _collector;
0 a61af66fc99e Initial load duke parents: diff changeset	374 MemRegion _span;
a61af66fc99e Initial load duke parents: diff changeset	375 OopTaskQueue* _work_queue;
a61af66fc99e Initial load duke parents: diff changeset	376 CMSBitMap* _bit_map;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	377 protected:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	378 DO_OOP_WORK_DEFN
0 a61af66fc99e Initial load duke parents: diff changeset	379 public:
a61af66fc99e Initial load duke parents: diff changeset	380 CMSInnerParMarkAndPushClosure(CMSCollector* collector,
a61af66fc99e Initial load duke parents: diff changeset	381 MemRegion span, CMSBitMap* bit_map,
935 05f89f00a864 6798898: CMS: bugs related to class unloading jmasa parents: 452 diff changeset	382 OopTaskQueue* work_queue);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	383 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	384 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	385 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	386 inline void do_oop_nv(narrowOop* p) { CMSInnerParMarkAndPushClosure::do_oop_work(p); }
0 a61af66fc99e Initial load duke parents: diff changeset	387 };
a61af66fc99e Initial load duke parents: diff changeset	388
a61af66fc99e Initial load duke parents: diff changeset	389 // A parallel (MT) version of the above, used when
a61af66fc99e Initial load duke parents: diff changeset	390 // reference processing is parallel; the only difference
a61af66fc99e Initial load duke parents: diff changeset	391 // is in the do_oop method.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	392 class CMSParKeepAliveClosure: public CMSOopClosure {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	393 private:
0 a61af66fc99e Initial load duke parents: diff changeset	394 MemRegion _span;
a61af66fc99e Initial load duke parents: diff changeset	395 OopTaskQueue* _work_queue;
a61af66fc99e Initial load duke parents: diff changeset	396 CMSBitMap* _bit_map;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	397 CMSInnerParMarkAndPushClosure
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	398 _mark_and_push;
0 a61af66fc99e Initial load duke parents: diff changeset	399 const uint _low_water_mark;
a61af66fc99e Initial load duke parents: diff changeset	400 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	401 protected:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	402 DO_OOP_WORK_DEFN
0 a61af66fc99e Initial load duke parents: diff changeset	403 public:
a61af66fc99e Initial load duke parents: diff changeset	404 CMSParKeepAliveClosure(CMSCollector* collector, MemRegion span,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 1972 diff changeset	405 CMSBitMap* bit_map, 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);
0 a61af66fc99e Initial load duke parents: diff changeset	408 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	409
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	410 #endif // SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_CMSOOPCLOSURES_HPP

Mercurial > hg > graal-compiler

annotate src/share/vm/gc_implementation/concurrentMarkSweep/cmsOopClosures.hpp @ 10185:d50cc62e94ff