Mercurial > hg > truffle

annotate src/share/vm/gc_implementation/g1/g1EvacFailure.hpp @ 8733:9def4075da6d

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
8008079: G1: Add nextObject routine to CMBitMapRO and replace nextWord Summary: Update the task local finger to the start of the next object when marking aborts, in order to avoid the redundant scanning of all 0's when the marking task restarts, if otherwise updating to the next word. In addition, reuse the routine nextObject() in routine iterate(). Reviewed-by: johnc, ysr Contributed-by: tamao <tao.mao@oracle.com>
author tamao
date Tue, 05 Mar 2013 15:36:56 -0800
parents eff609af17d7
children d55c004e1d4d
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
4783
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
1 /*
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
2 * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
4 *
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
5 * This code is free software; you can redistribute it and/or modify it
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
6 * under the terms of the GNU General Public License version 2 only, as
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
7 * published by the Free Software Foundation.
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
8 *
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
9 * This code is distributed in the hope that it will be useful, but WITHOUT
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
12 * version 2 for more details (a copy is included in the LICENSE file that
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
13 * accompanied this code).
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
14 *
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
15 * You should have received a copy of the GNU General Public License version
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
16 * 2 along with this work; if not, write to the Free Software Foundation,
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
18 *
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
20 * or visit www.oracle.com if you need additional information or have any
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
21 * questions.
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
22 *
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
23 */
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
24
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
25 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_G1EVACFAILURE_HPP
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
26 #define SHARE_VM_GC_IMPLEMENTATION_G1_G1EVACFAILURE_HPP
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
27
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
28 #include "gc_implementation/g1/concurrentMark.inline.hpp"
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
29 #include "gc_implementation/g1/dirtyCardQueue.hpp"
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
30 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
31 #include "gc_implementation/g1/g1_globals.hpp"
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
32 #include "gc_implementation/g1/g1OopClosures.inline.hpp"
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
33 #include "gc_implementation/g1/heapRegion.hpp"
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
34 #include "gc_implementation/g1/heapRegionRemSet.hpp"
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
35 #include "utilities/workgroup.hpp"
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
36
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
37 // Closures and tasks associated with any self-forwarding pointers
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
38 // installed as a result of an evacuation failure.
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
39
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
40 class UpdateRSetDeferred : public OopsInHeapRegionClosure {
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
41 private:
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
42 G1CollectedHeap* _g1;
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
43 DirtyCardQueue *_dcq;
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
44 CardTableModRefBS* _ct_bs;
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
45
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
46 public:
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
47 UpdateRSetDeferred(G1CollectedHeap* g1, DirtyCardQueue* dcq) :
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
48 _g1(g1), _ct_bs((CardTableModRefBS*)_g1->barrier_set()), _dcq(dcq) {}
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
49
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
50 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
51 virtual void do_oop( oop* p) { do_oop_work(p); }
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
52 template <class T> void do_oop_work(T* p) {
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
53 assert(_from->is_in_reserved(p), "paranoia");
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
54 if (!_from->is_in_reserved(oopDesc::load_decode_heap_oop(p)) &&
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
55 !_from->is_survivor()) {
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
56 size_t card_index = _ct_bs->index_for(p);
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
57 if (_ct_bs->mark_card_deferred(card_index)) {
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
58 _dcq->enqueue((jbyte*)_ct_bs->byte_for_index(card_index));
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
59 }
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
60 }
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
61 }
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
62 };
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
63
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
64 class RemoveSelfForwardPtrObjClosure: public ObjectClosure {
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
65 private:
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
66 G1CollectedHeap* _g1;
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
67 ConcurrentMark* _cm;
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
68 HeapRegion* _hr;
4787
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
69 size_t _marked_bytes;
4783
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
70 OopsInHeapRegionClosure *_update_rset_cl;
4787
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
71 bool _during_initial_mark;
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
72 bool _during_conc_mark;
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4787
diff changeset
73 uint _worker_id;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4787
diff changeset
74
4783
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
75 public:
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
76 RemoveSelfForwardPtrObjClosure(G1CollectedHeap* g1, ConcurrentMark* cm,
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
77 HeapRegion* hr,
4787
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
78 OopsInHeapRegionClosure* update_rset_cl,
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
79 bool during_initial_mark,
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4787
diff changeset
80 bool during_conc_mark,
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4787
diff changeset
81 uint worker_id) :
4787
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
82 _g1(g1), _cm(cm), _hr(hr), _marked_bytes(0),
4783
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
83 _update_rset_cl(update_rset_cl),
4787
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
84 _during_initial_mark(during_initial_mark),
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4787
diff changeset
85 _during_conc_mark(during_conc_mark),
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4787
diff changeset
86 _worker_id(worker_id) { }
4783
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
87
4787
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
88 size_t marked_bytes() { return _marked_bytes; }
4783
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
89
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
90 // <original comment>
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
91 // The original idea here was to coalesce evacuated and dead objects.
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
92 // However that caused complications with the block offset table (BOT).
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
93 // In particular if there were two TLABs, one of them partially refined.
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
94 // |----- TLAB_1--------|----TLAB_2-~~~(partially refined part)~~~|
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
95 // The BOT entries of the unrefined part of TLAB_2 point to the start
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
96 // of TLAB_2. If the last object of the TLAB_1 and the first object
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
97 // of TLAB_2 are coalesced, then the cards of the unrefined part
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
98 // would point into middle of the filler object.
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
99 // The current approach is to not coalesce and leave the BOT contents intact.
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
100 // </original comment>
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
101 //
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
102 // We now reset the BOT when we start the object iteration over the
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
103 // region and refine its entries for every object we come across. So
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
104 // the above comment is not really relevant and we should be able
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
105 // to coalesce dead objects if we want to.
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
106 void do_object(oop obj) {
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
107 HeapWord* obj_addr = (HeapWord*) obj;
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
108 assert(_hr->is_in(obj_addr), "sanity");
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
109 size_t obj_size = obj->size();
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
110 _hr->update_bot_for_object(obj_addr, obj_size);
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
111
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
112 if (obj->is_forwarded() && obj->forwardee() == obj) {
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
113 // The object failed to move.
4787
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
114
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
115 // We consider all objects that we find self-forwarded to be
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
116 // live. What we'll do is that we'll update the prev marking
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
117 // info so that they are all under PTAMS and explicitly marked.
4783
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
118 _cm->markPrev(obj);
4787
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
119 if (_during_initial_mark) {
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
120 // For the next marking info we'll only mark the
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
121 // self-forwarded objects explicitly if we are during
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
122 // initial-mark (since, normally, we only mark objects pointed
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
123 // to by roots if we succeed in copying them). By marking all
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
124 // self-forwarded objects we ensure that we mark any that are
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
125 // still pointed to be roots. During concurrent marking, and
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
126 // after initial-mark, we don't need to mark any objects
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
127 // explicitly and all objects in the CSet are considered
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
128 // (implicitly) live. So, we won't mark them explicitly and
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
129 // we'll leave them over NTAMS.
4837
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
130 _cm->grayRoot(obj, obj_size, _worker_id, _hr);
4783
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
131 }
4787
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
132 _marked_bytes += (obj_size * HeapWordSize);
4783
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
133 obj->set_mark(markOopDesc::prototype());
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
134
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
135 // While we were processing RSet buffers during the collection,
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
136 // we actually didn't scan any cards on the collection set,
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
137 // since we didn't want to update remembered sets with entries
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
138 // that point into the collection set, given that live objects
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
139 // from the collection set are about to move and such entries
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
140 // will be stale very soon.
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
141 // This change also dealt with a reliability issue which
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
142 // involved scanning a card in the collection set and coming
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
143 // across an array that was being chunked and looking malformed.
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
144 // The problem is that, if evacuation fails, we might have
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
145 // remembered set entries missing given that we skipped cards on
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
146 // the collection set. So, we'll recreate such entries now.
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
147 obj->oop_iterate(_update_rset_cl);
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
148 assert(_cm->isPrevMarked(obj), "Should be marked!");
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
149 } else {
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
150 // The object has been either evacuated or is dead. Fill it with a
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
151 // dummy object.
4787
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
152 MemRegion mr((HeapWord*) obj, obj_size);
4783
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
153 CollectedHeap::fill_with_object(mr);
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
154 }
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
155 }
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
156 };
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
157
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
158 class RemoveSelfForwardPtrHRClosure: public HeapRegionClosure {
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
159 G1CollectedHeap* _g1h;
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
160 ConcurrentMark* _cm;
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
161 OopsInHeapRegionClosure *_update_rset_cl;
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4787
diff changeset
162 uint _worker_id;
4783
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
163
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
164 public:
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
165 RemoveSelfForwardPtrHRClosure(G1CollectedHeap* g1h,
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4787
diff changeset
166 OopsInHeapRegionClosure* update_rset_cl,
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4787
diff changeset
167 uint worker_id) :
4783
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
168 _g1h(g1h), _update_rset_cl(update_rset_cl),
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4787
diff changeset
169 _worker_id(worker_id), _cm(_g1h->concurrent_mark()) { }
4783
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
170
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
171 bool doHeapRegion(HeapRegion *hr) {
4787
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
172 bool during_initial_mark = _g1h->g1_policy()->during_initial_mark_pause();
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
173 bool during_conc_mark = _g1h->mark_in_progress();
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
174
4783
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
175 assert(!hr->isHumongous(), "sanity");
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
176 assert(hr->in_collection_set(), "bad CS");
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
177
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
178 if (hr->claimHeapRegion(HeapRegion::ParEvacFailureClaimValue)) {
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
179 if (hr->evacuation_failed()) {
4787
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
180 RemoveSelfForwardPtrObjClosure rspc(_g1h, _cm, hr, _update_rset_cl,
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
181 during_initial_mark,
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4787
diff changeset
182 during_conc_mark,
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4787
diff changeset
183 _worker_id);
4787
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
184
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
185 MemRegion mr(hr->bottom(), hr->end());
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
186 // We'll recreate the prev marking info so we'll first clear
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
187 // the prev bitmap range for this region. We never mark any
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
188 // CSet objects explicitly so the next bitmap range should be
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
189 // cleared anyway.
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
190 _cm->clearRangePrevBitmap(mr);
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
191
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
192 hr->note_self_forwarding_removal_start(during_initial_mark,
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
193 during_conc_mark);
4783
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
194
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
195 // In the common case (i.e. when there is no evacuation
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
196 // failure) we make sure that the following is done when
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
197 // the region is freed so that it is "ready-to-go" when it's
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
198 // re-allocated. However, when evacuation failure happens, a
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
199 // region will remain in the heap and might ultimately be added
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
200 // to a CSet in the future. So we have to be careful here and
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
201 // make sure the region's RSet is ready for parallel iteration
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
202 // whenever this might be required in the future.
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
203 hr->rem_set()->reset_for_par_iteration();
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
204 hr->reset_bot();
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
205 _update_rset_cl->set_region(hr);
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
206 hr->object_iterate(&rspc);
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
207
4787
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
208 hr->note_self_forwarding_removal_end(during_initial_mark,
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
209 during_conc_mark,
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
210 rspc.marked_bytes());
4783
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
211 }
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
212 }
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
213 return false;
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
214 }
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
215 };
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
216
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
217 class G1ParRemoveSelfForwardPtrsTask: public AbstractGangTask {
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
218 protected:
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
219 G1CollectedHeap* _g1h;
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
220
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
221 public:
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
222 G1ParRemoveSelfForwardPtrsTask(G1CollectedHeap* g1h) :
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
223 AbstractGangTask("G1 Remove Self-forwarding Pointers"),
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
224 _g1h(g1h) { }
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
225
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
226 void work(uint worker_id) {
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
227 UpdateRSetImmediate immediate_update(_g1h->g1_rem_set());
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
228 DirtyCardQueue dcq(&_g1h->dirty_card_queue_set());
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
229 UpdateRSetDeferred deferred_update(_g1h, &dcq);
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
230
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
231 OopsInHeapRegionClosure *update_rset_cl = &deferred_update;
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
232 if (!G1DeferredRSUpdate) {
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
233 update_rset_cl = &immediate_update;
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
234 }
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
235
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4787
diff changeset
236 RemoveSelfForwardPtrHRClosure rsfp_cl(_g1h, update_rset_cl, worker_id);
4783
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
237
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
238 HeapRegion* hr = _g1h->start_cset_region_for_worker(worker_id);
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
239 _g1h->collection_set_iterate_from(hr, &rsfp_cl);
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
240 }
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
241 };
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
242
023652e49ac0 7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
diff changeset
243 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1EVACFAILURE_HPP