Mercurial > hg > graal-compiler
annotate src/share/vm/gc_implementation/g1/concurrentMark.inline.hpp @ 6812:988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
Summary: The clipping code in the routine that sets the bits for a range of cards, in the liveness accounting verification code was incorrect. It set all the bits in the card bitmap from the given starting index which would lead to spurious marking verification failures.
Reviewed-by: brutisso, jwilhelm, jmasa
author | johnc |
---|---|
date | Thu, 27 Sep 2012 15:44:01 -0700 |
parents | 720b6a76dd9d |
children | 8a5ea0a9ccc4 |
rev | line source |
---|---|
3771 | 1 /* |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3776
diff
changeset
|
2 * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. |
3771 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 * | |
5 * This code is free software; you can redistribute it and/or modify it | |
6 * under the terms of the GNU General Public License version 2 only, as | |
7 * published by the Free Software Foundation. | |
8 * | |
9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
12 * version 2 for more details (a copy is included in the LICENSE file that | |
13 * accompanied this code). | |
14 * | |
15 * You should have received a copy of the GNU General Public License version | |
16 * 2 along with this work; if not, write to the Free Software Foundation, | |
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
18 * | |
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | |
20 * or visit www.oracle.com if you need additional information or have any | |
21 * questions. | |
22 * | |
23 */ | |
24 | |
25 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_CONCURRENTMARK_INLINE_HPP | |
26 #define SHARE_VM_GC_IMPLEMENTATION_G1_CONCURRENTMARK_INLINE_HPP | |
27 | |
28 #include "gc_implementation/g1/concurrentMark.hpp" | |
29 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" | |
30 | |
6812
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
31 // Utility routine to set an exclusive range of cards on the given |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
32 // card liveness bitmap |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
33 inline void ConcurrentMark::set_card_bitmap_range(BitMap* card_bm, |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
34 BitMap::idx_t start_idx, |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
35 BitMap::idx_t end_idx, |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
36 bool is_par) { |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
37 |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
38 // Set the exclusive bit range [start_idx, end_idx). |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
39 assert((end_idx - start_idx) > 0, "at least one card"); |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
40 assert(end_idx <= card_bm->size(), "sanity"); |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
41 |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
42 // Silently clip the end index |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
43 end_idx = MIN2(end_idx, card_bm->size()); |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
44 |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
45 // For small ranges use a simple loop; otherwise use set_range or |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
46 // use par_at_put_range (if parallel). The range is made up of the |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
47 // cards that are spanned by an object/mem region so 8 cards will |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
48 // allow up to object sizes up to 4K to be handled using the loop. |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
49 if ((end_idx - start_idx) <= 8) { |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
50 for (BitMap::idx_t i = start_idx; i < end_idx; i += 1) { |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
51 if (is_par) { |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
52 card_bm->par_set_bit(i); |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
53 } else { |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
54 card_bm->set_bit(i); |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
55 } |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
56 } |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
57 } else { |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
58 // Note BitMap::par_at_put_range() and BitMap::set_range() are exclusive. |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
59 if (is_par) { |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
60 card_bm->par_at_put_range(start_idx, end_idx, true); |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
61 } else { |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
62 card_bm->set_range(start_idx, end_idx); |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
63 } |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
64 } |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
65 } |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
66 |
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
67 // Returns the index in the liveness accounting card bitmap |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
68 // for the given address |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
69 inline BitMap::idx_t ConcurrentMark::card_bitmap_index_for(HeapWord* addr) { |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
70 // Below, the term "card num" means the result of shifting an address |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
71 // by the card shift -- address 0 corresponds to card number 0. One |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
72 // must subtract the card num of the bottom of the heap to obtain a |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
73 // card table index. |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
74 intptr_t card_num = intptr_t(uintptr_t(addr) >> CardTableModRefBS::card_shift); |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
75 return card_num - heap_bottom_card_num(); |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
76 } |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
77 |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
78 // Counts the given memory region in the given task/worker |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
79 // counting data structures. |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
80 inline void ConcurrentMark::count_region(MemRegion mr, HeapRegion* hr, |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
81 size_t* marked_bytes_array, |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
82 BitMap* task_card_bm) { |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
83 G1CollectedHeap* g1h = _g1h; |
6812
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
84 CardTableModRefBS* ct_bs = (CardTableModRefBS*) (g1h->barrier_set()); |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
85 |
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
86 HeapWord* start = mr.start(); |
6812
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
87 HeapWord* end = mr.end(); |
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
88 size_t region_size_bytes = mr.byte_size(); |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
4837
diff
changeset
|
89 uint index = hr->hrs_index(); |
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
90 |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
91 assert(!hr->continuesHumongous(), "should not be HC region"); |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
92 assert(hr == g1h->heap_region_containing(start), "sanity"); |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
93 assert(hr == g1h->heap_region_containing(mr.last()), "sanity"); |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
94 assert(marked_bytes_array != NULL, "pre-condition"); |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
95 assert(task_card_bm != NULL, "pre-condition"); |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
96 |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
97 // Add to the task local marked bytes for this region. |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
98 marked_bytes_array[index] += region_size_bytes; |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
99 |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
100 BitMap::idx_t start_idx = card_bitmap_index_for(start); |
6812
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
101 BitMap::idx_t end_idx = card_bitmap_index_for(end); |
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
102 |
6812
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
103 // Note: if we're looking at the last region in heap - end |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
104 // could be actually just beyond the end of the heap; end_idx |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
105 // will then correspond to a (non-existent) card that is also |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
106 // just beyond the heap. |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
107 if (g1h->is_in_g1_reserved(end) && !ct_bs->is_card_aligned(end)) { |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
108 // end of region is not card aligned - incremement to cover |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
109 // all the cards spanned by the region. |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
110 end_idx += 1; |
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
111 } |
6812
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
112 // The card bitmap is task/worker specific => no need to use |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
113 // the 'par' BitMap routines. |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
114 // Set bits in the exclusive bit range [start_idx, end_idx). |
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6010
diff
changeset
|
115 set_card_bitmap_range(task_card_bm, start_idx, end_idx, false /* is_par */); |
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
116 } |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
117 |
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
118 // Counts the given memory region in the task/worker counting |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
119 // data structures for the given worker id. |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
120 inline void ConcurrentMark::count_region(MemRegion mr, |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
121 HeapRegion* hr, |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
122 uint worker_id) { |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
123 size_t* marked_bytes_array = count_marked_bytes_array_for(worker_id); |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
124 BitMap* task_card_bm = count_card_bitmap_for(worker_id); |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
125 count_region(mr, hr, marked_bytes_array, task_card_bm); |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
126 } |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
127 |
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
128 // Counts the given memory region, which may be a single object, in the |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
129 // task/worker counting data structures for the given worker id. |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
130 inline void ConcurrentMark::count_region(MemRegion mr, uint worker_id) { |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
131 HeapWord* addr = mr.start(); |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
132 HeapRegion* hr = _g1h->heap_region_containing_raw(addr); |
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
133 count_region(mr, hr, worker_id); |
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
134 } |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
135 |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
136 // Counts the given object in the given task/worker counting data structures. |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
137 inline void ConcurrentMark::count_object(oop obj, |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
138 HeapRegion* hr, |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
139 size_t* marked_bytes_array, |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
140 BitMap* task_card_bm) { |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
141 MemRegion mr((HeapWord*)obj, obj->size()); |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
142 count_region(mr, hr, marked_bytes_array, task_card_bm); |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
143 } |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
144 |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
145 // Counts the given object in the task/worker counting data |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
146 // structures for the given worker id. |
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
147 inline void ConcurrentMark::count_object(oop obj, |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
148 HeapRegion* hr, |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
149 uint worker_id) { |
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
150 size_t* marked_bytes_array = count_marked_bytes_array_for(worker_id); |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
151 BitMap* task_card_bm = count_card_bitmap_for(worker_id); |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
152 HeapWord* addr = (HeapWord*) obj; |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
153 count_object(obj, hr, marked_bytes_array, task_card_bm); |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
154 } |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
155 |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
156 // Attempts to mark the given object and, if successful, counts |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
157 // the object in the given task/worker counting structures. |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
158 inline bool ConcurrentMark::par_mark_and_count(oop obj, |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
159 HeapRegion* hr, |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
160 size_t* marked_bytes_array, |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
161 BitMap* task_card_bm) { |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
162 HeapWord* addr = (HeapWord*)obj; |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
163 if (_nextMarkBitMap->parMark(addr)) { |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
164 // Update the task specific count data for the object. |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
165 count_object(obj, hr, marked_bytes_array, task_card_bm); |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
166 return true; |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
167 } |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
168 return false; |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
169 } |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
170 |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
171 // Attempts to mark the given object and, if successful, counts |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
172 // the object in the task/worker counting structures for the |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
173 // given worker id. |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
174 inline bool ConcurrentMark::par_mark_and_count(oop obj, |
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
175 size_t word_size, |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
176 HeapRegion* hr, |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
177 uint worker_id) { |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
178 HeapWord* addr = (HeapWord*)obj; |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
179 if (_nextMarkBitMap->parMark(addr)) { |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
180 MemRegion mr(addr, word_size); |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
181 count_region(mr, hr, worker_id); |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
182 return true; |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
183 } |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
184 return false; |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
185 } |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
186 |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
187 // Attempts to mark the given object and, if successful, counts |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
188 // the object in the task/worker counting structures for the |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
189 // given worker id. |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
190 inline bool ConcurrentMark::par_mark_and_count(oop obj, |
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
191 HeapRegion* hr, |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
192 uint worker_id) { |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
193 HeapWord* addr = (HeapWord*)obj; |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
194 if (_nextMarkBitMap->parMark(addr)) { |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
195 // Update the task specific count data for the object. |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
196 count_object(obj, hr, worker_id); |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
197 return true; |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
198 } |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
199 return false; |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
200 } |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
201 |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
202 // As above - but we don't know the heap region containing the |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
203 // object and so have to supply it. |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
204 inline bool ConcurrentMark::par_mark_and_count(oop obj, uint worker_id) { |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
205 HeapWord* addr = (HeapWord*)obj; |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
206 HeapRegion* hr = _g1h->heap_region_containing_raw(addr); |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
207 return par_mark_and_count(obj, hr, worker_id); |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
208 } |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
209 |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
210 // Similar to the above routine but we already know the size, in words, of |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
211 // the object that we wish to mark/count |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
212 inline bool ConcurrentMark::par_mark_and_count(oop obj, |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
213 size_t word_size, |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
214 uint worker_id) { |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
215 HeapWord* addr = (HeapWord*)obj; |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
216 if (_nextMarkBitMap->parMark(addr)) { |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
217 // Update the task specific count data for the object. |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
218 MemRegion mr(addr, word_size); |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
219 count_region(mr, worker_id); |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
220 return true; |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
221 } |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
222 return false; |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
223 } |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
224 |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
225 // Unconditionally mark the given object, and unconditinally count |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
226 // the object in the counting structures for worker id 0. |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
227 // Should *not* be called from parallel code. |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
228 inline bool ConcurrentMark::mark_and_count(oop obj, HeapRegion* hr) { |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
229 HeapWord* addr = (HeapWord*)obj; |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
230 _nextMarkBitMap->mark(addr); |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
231 // Update the task specific count data for the object. |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
232 count_object(obj, hr, 0 /* worker_id */); |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
233 return true; |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
234 } |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
235 |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
236 // As above - but we don't have the heap region containing the |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
237 // object, so we have to supply it. |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
238 inline bool ConcurrentMark::mark_and_count(oop obj) { |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
239 HeapWord* addr = (HeapWord*)obj; |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
240 HeapRegion* hr = _g1h->heap_region_containing_raw(addr); |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
241 return mark_and_count(obj, hr); |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
242 } |
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
243 |
4827
2e966d967c5c
7121547: G1: High number mispredicted branches while iterating over the marking bitmap
johnc
parents:
4787
diff
changeset
|
244 inline bool CMBitMapRO::iterate(BitMapClosure* cl, MemRegion mr) { |
2e966d967c5c
7121547: G1: High number mispredicted branches while iterating over the marking bitmap
johnc
parents:
4787
diff
changeset
|
245 HeapWord* start_addr = MAX2(startWord(), mr.start()); |
2e966d967c5c
7121547: G1: High number mispredicted branches while iterating over the marking bitmap
johnc
parents:
4787
diff
changeset
|
246 HeapWord* end_addr = MIN2(endWord(), mr.end()); |
2e966d967c5c
7121547: G1: High number mispredicted branches while iterating over the marking bitmap
johnc
parents:
4787
diff
changeset
|
247 |
2e966d967c5c
7121547: G1: High number mispredicted branches while iterating over the marking bitmap
johnc
parents:
4787
diff
changeset
|
248 if (end_addr > start_addr) { |
2e966d967c5c
7121547: G1: High number mispredicted branches while iterating over the marking bitmap
johnc
parents:
4787
diff
changeset
|
249 // Right-open interval [start-offset, end-offset). |
2e966d967c5c
7121547: G1: High number mispredicted branches while iterating over the marking bitmap
johnc
parents:
4787
diff
changeset
|
250 BitMap::idx_t start_offset = heapWordToOffset(start_addr); |
2e966d967c5c
7121547: G1: High number mispredicted branches while iterating over the marking bitmap
johnc
parents:
4787
diff
changeset
|
251 BitMap::idx_t end_offset = heapWordToOffset(end_addr); |
2e966d967c5c
7121547: G1: High number mispredicted branches while iterating over the marking bitmap
johnc
parents:
4787
diff
changeset
|
252 |
2e966d967c5c
7121547: G1: High number mispredicted branches while iterating over the marking bitmap
johnc
parents:
4787
diff
changeset
|
253 start_offset = _bm.get_next_one_offset(start_offset, end_offset); |
2e966d967c5c
7121547: G1: High number mispredicted branches while iterating over the marking bitmap
johnc
parents:
4787
diff
changeset
|
254 while (start_offset < end_offset) { |
2e966d967c5c
7121547: G1: High number mispredicted branches while iterating over the marking bitmap
johnc
parents:
4787
diff
changeset
|
255 HeapWord* obj_addr = offsetToHeapWord(start_offset); |
2e966d967c5c
7121547: G1: High number mispredicted branches while iterating over the marking bitmap
johnc
parents:
4787
diff
changeset
|
256 oop obj = (oop) obj_addr; |
2e966d967c5c
7121547: G1: High number mispredicted branches while iterating over the marking bitmap
johnc
parents:
4787
diff
changeset
|
257 if (!cl->do_bit(start_offset)) { |
2e966d967c5c
7121547: G1: High number mispredicted branches while iterating over the marking bitmap
johnc
parents:
4787
diff
changeset
|
258 return false; |
2e966d967c5c
7121547: G1: High number mispredicted branches while iterating over the marking bitmap
johnc
parents:
4787
diff
changeset
|
259 } |
2e966d967c5c
7121547: G1: High number mispredicted branches while iterating over the marking bitmap
johnc
parents:
4787
diff
changeset
|
260 HeapWord* next_addr = MIN2(obj_addr + obj->size(), end_addr); |
2e966d967c5c
7121547: G1: High number mispredicted branches while iterating over the marking bitmap
johnc
parents:
4787
diff
changeset
|
261 BitMap::idx_t next_offset = heapWordToOffset(next_addr); |
2e966d967c5c
7121547: G1: High number mispredicted branches while iterating over the marking bitmap
johnc
parents:
4787
diff
changeset
|
262 start_offset = _bm.get_next_one_offset(next_offset, end_offset); |
2e966d967c5c
7121547: G1: High number mispredicted branches while iterating over the marking bitmap
johnc
parents:
4787
diff
changeset
|
263 } |
2e966d967c5c
7121547: G1: High number mispredicted branches while iterating over the marking bitmap
johnc
parents:
4787
diff
changeset
|
264 } |
2e966d967c5c
7121547: G1: High number mispredicted branches while iterating over the marking bitmap
johnc
parents:
4787
diff
changeset
|
265 return true; |
2e966d967c5c
7121547: G1: High number mispredicted branches while iterating over the marking bitmap
johnc
parents:
4787
diff
changeset
|
266 } |
2e966d967c5c
7121547: G1: High number mispredicted branches while iterating over the marking bitmap
johnc
parents:
4787
diff
changeset
|
267 |
2e966d967c5c
7121547: G1: High number mispredicted branches while iterating over the marking bitmap
johnc
parents:
4787
diff
changeset
|
268 inline bool CMBitMapRO::iterate(BitMapClosure* cl) { |
2e966d967c5c
7121547: G1: High number mispredicted branches while iterating over the marking bitmap
johnc
parents:
4787
diff
changeset
|
269 MemRegion mr(startWord(), sizeInWords()); |
2e966d967c5c
7121547: G1: High number mispredicted branches while iterating over the marking bitmap
johnc
parents:
4787
diff
changeset
|
270 return iterate(cl, mr); |
2e966d967c5c
7121547: G1: High number mispredicted branches while iterating over the marking bitmap
johnc
parents:
4787
diff
changeset
|
271 } |
2e966d967c5c
7121547: G1: High number mispredicted branches while iterating over the marking bitmap
johnc
parents:
4787
diff
changeset
|
272 |
3771 | 273 inline void CMTask::push(oop obj) { |
274 HeapWord* objAddr = (HeapWord*) obj; | |
275 assert(_g1h->is_in_g1_reserved(objAddr), "invariant"); | |
276 assert(!_g1h->is_on_master_free_list( | |
277 _g1h->heap_region_containing((HeapWord*) objAddr)), "invariant"); | |
278 assert(!_g1h->is_obj_ill(obj), "invariant"); | |
279 assert(_nextMarkBitMap->isMarked(objAddr), "invariant"); | |
280 | |
281 if (_cm->verbose_high()) { | |
282 gclog_or_tty->print_cr("[%d] pushing "PTR_FORMAT, _task_id, (void*) obj); | |
283 } | |
284 | |
285 if (!_task_queue->push(obj)) { | |
286 // The local task queue looks full. We need to push some entries | |
287 // to the global stack. | |
288 | |
289 if (_cm->verbose_medium()) { | |
290 gclog_or_tty->print_cr("[%d] task queue overflow, " | |
291 "moving entries to the global stack", | |
292 _task_id); | |
293 } | |
294 move_entries_to_global_stack(); | |
295 | |
296 // this should succeed since, even if we overflow the global | |
297 // stack, we should have definitely removed some entries from the | |
298 // local queue. So, there must be space on it. | |
299 bool success = _task_queue->push(obj); | |
300 assert(success, "invariant"); | |
301 } | |
302 | |
303 statsOnly( int tmp_size = _task_queue->size(); | |
3776
23d434c6290d
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
3771
diff
changeset
|
304 if (tmp_size > _local_max_size) { |
3771 | 305 _local_max_size = tmp_size; |
3776
23d434c6290d
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
3771
diff
changeset
|
306 } |
3771 | 307 ++_local_pushes ); |
308 } | |
309 | |
310 // This determines whether the method below will check both the local | |
311 // and global fingers when determining whether to push on the stack a | |
312 // gray object (value 1) or whether it will only check the global one | |
313 // (value 0). The tradeoffs are that the former will be a bit more | |
314 // accurate and possibly push less on the stack, but it might also be | |
315 // a little bit slower. | |
316 | |
317 #define _CHECK_BOTH_FINGERS_ 1 | |
318 | |
319 inline void CMTask::deal_with_reference(oop obj) { | |
320 if (_cm->verbose_high()) { | |
321 gclog_or_tty->print_cr("[%d] we're dealing with reference = "PTR_FORMAT, | |
322 _task_id, (void*) obj); | |
323 } | |
324 | |
325 ++_refs_reached; | |
326 | |
327 HeapWord* objAddr = (HeapWord*) obj; | |
328 assert(obj->is_oop_or_null(true /* ignore mark word */), "Error"); | |
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
329 if (_g1h->is_in_g1_reserved(objAddr)) { |
3771 | 330 assert(obj != NULL, "null check is implicit"); |
331 if (!_nextMarkBitMap->isMarked(objAddr)) { | |
332 // Only get the containing region if the object is not marked on the | |
333 // bitmap (otherwise, it's a waste of time since we won't do | |
334 // anything with it). | |
335 HeapRegion* hr = _g1h->heap_region_containing_raw(obj); | |
336 if (!hr->obj_allocated_since_next_marking(obj)) { | |
337 if (_cm->verbose_high()) { | |
338 gclog_or_tty->print_cr("[%d] "PTR_FORMAT" is not considered marked", | |
339 _task_id, (void*) obj); | |
340 } | |
341 | |
342 // we need to mark it first | |
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
343 if (_cm->par_mark_and_count(obj, hr, _marked_bytes_array, _card_bm)) { |
3771 | 344 // No OrderAccess:store_load() is needed. It is implicit in the |
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4827
diff
changeset
|
345 // CAS done in CMBitMap::parMark() call in the routine above. |
3771 | 346 HeapWord* global_finger = _cm->finger(); |
347 | |
348 #if _CHECK_BOTH_FINGERS_ | |
349 // we will check both the local and global fingers | |
350 | |
351 if (_finger != NULL && objAddr < _finger) { | |
352 if (_cm->verbose_high()) { | |
353 gclog_or_tty->print_cr("[%d] below the local finger ("PTR_FORMAT"), " | |
354 "pushing it", _task_id, _finger); | |
355 } | |
356 push(obj); | |
357 } else if (_curr_region != NULL && objAddr < _region_limit) { | |
358 // do nothing | |
359 } else if (objAddr < global_finger) { | |
360 // Notice that the global finger might be moving forward | |
361 // concurrently. This is not a problem. In the worst case, we | |
362 // mark the object while it is above the global finger and, by | |
363 // the time we read the global finger, it has moved forward | |
364 // passed this object. In this case, the object will probably | |
365 // be visited when a task is scanning the region and will also | |
366 // be pushed on the stack. So, some duplicate work, but no | |
367 // correctness problems. | |
368 | |
369 if (_cm->verbose_high()) { | |
370 gclog_or_tty->print_cr("[%d] below the global finger " | |
371 "("PTR_FORMAT"), pushing it", | |
372 _task_id, global_finger); | |
373 } | |
374 push(obj); | |
375 } else { | |
376 // do nothing | |
377 } | |
378 #else // _CHECK_BOTH_FINGERS_ | |
379 // we will only check the global finger | |
380 | |
381 if (objAddr < global_finger) { | |
382 // see long comment above | |
383 | |
384 if (_cm->verbose_high()) { | |
385 gclog_or_tty->print_cr("[%d] below the global finger " | |
386 "("PTR_FORMAT"), pushing it", | |
387 _task_id, global_finger); | |
388 } | |
389 push(obj); | |
390 } | |
391 #endif // _CHECK_BOTH_FINGERS_ | |
392 } | |
393 } | |
394 } | |
395 } | |
396 } | |
397 | |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3776
diff
changeset
|
398 inline void ConcurrentMark::markPrev(oop p) { |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3776
diff
changeset
|
399 assert(!_prevMarkBitMap->isMarked((HeapWord*) p), "sanity"); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3776
diff
changeset
|
400 // Note we are overriding the read-only view of the prev map here, via |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3776
diff
changeset
|
401 // the cast. |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3776
diff
changeset
|
402 ((CMBitMap*)_prevMarkBitMap)->mark((HeapWord*) p); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3776
diff
changeset
|
403 } |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3776
diff
changeset
|
404 |
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
405 inline void ConcurrentMark::grayRoot(oop obj, size_t word_size, |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
406 uint worker_id, HeapRegion* hr) { |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
407 assert(obj != NULL, "pre-condition"); |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3776
diff
changeset
|
408 HeapWord* addr = (HeapWord*) obj; |
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
409 if (hr == NULL) { |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
410 hr = _g1h->heap_region_containing_raw(addr); |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
411 } else { |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
412 assert(hr->is_in(addr), "pre-condition"); |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
413 } |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
414 assert(hr != NULL, "sanity"); |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
415 // Given that we're looking for a region that contains an object |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
416 // header it's impossible to get back a HC region. |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
417 assert(!hr->continuesHumongous(), "sanity"); |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3776
diff
changeset
|
418 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3776
diff
changeset
|
419 // We cannot assert that word_size == obj->size() given that obj |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3776
diff
changeset
|
420 // might not be in a consistent state (another thread might be in |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3776
diff
changeset
|
421 // the process of copying it). So the best thing we can do is to |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3776
diff
changeset
|
422 // assert that word_size is under an upper bound which is its |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3776
diff
changeset
|
423 // containing region's capacity. |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3776
diff
changeset
|
424 assert(word_size * HeapWordSize <= hr->capacity(), |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3776
diff
changeset
|
425 err_msg("size: "SIZE_FORMAT" capacity: "SIZE_FORMAT" "HR_FORMAT, |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3776
diff
changeset
|
426 word_size * HeapWordSize, hr->capacity(), |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3776
diff
changeset
|
427 HR_FORMAT_PARAMS(hr))); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3776
diff
changeset
|
428 |
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
429 if (addr < hr->next_top_at_mark_start()) { |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
430 if (!_nextMarkBitMap->isMarked(addr)) { |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
431 par_mark_and_count(obj, word_size, hr, worker_id); |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
432 } |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3776
diff
changeset
|
433 } |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3776
diff
changeset
|
434 } |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3776
diff
changeset
|
435 |
3771 | 436 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_CONCURRENTMARK_INLINE_HPP |