Mercurial > hg > truffle
annotate src/share/vm/gc_implementation/g1/g1EvacFailure.hpp @ 4912:a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
Summary: Revamp of the mechanism that chooses old regions for inclusion in the CSet. It simplifies the code and introduces min and max bounds on the number of old regions added to the CSet at each mixed GC to avoid pathological cases. It also ensures that when we do a mixed GC we'll always find old regions to add to the CSet (i.e., it eliminates the case where a mixed GC will collect no old regions which can happen today).
Reviewed-by: johnc, brutisso
author | tonyp |
---|---|
date | Wed, 15 Feb 2012 13:06:53 -0500 |
parents | eff609af17d7 |
children | d55c004e1d4d |
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 |