25 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_CONCURRENTMARK_INLINE_HPP |
25 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_CONCURRENTMARK_INLINE_HPP |
26 #define SHARE_VM_GC_IMPLEMENTATION_G1_CONCURRENTMARK_INLINE_HPP |
26 #define SHARE_VM_GC_IMPLEMENTATION_G1_CONCURRENTMARK_INLINE_HPP |
27 |
27 |
28 #include "gc_implementation/g1/concurrentMark.hpp" |
28 #include "gc_implementation/g1/concurrentMark.hpp" |
29 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" |
29 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" |
|
30 |
|
31 // Returns the index in the liveness accounting card bitmap |
|
32 // for the given address |
|
33 inline BitMap::idx_t ConcurrentMark::card_bitmap_index_for(HeapWord* addr) { |
|
34 // Below, the term "card num" means the result of shifting an address |
|
35 // by the card shift -- address 0 corresponds to card number 0. One |
|
36 // must subtract the card num of the bottom of the heap to obtain a |
|
37 // card table index. |
|
38 |
|
39 intptr_t card_num = intptr_t(uintptr_t(addr) >> CardTableModRefBS::card_shift); |
|
40 return card_num - heap_bottom_card_num(); |
|
41 } |
|
42 |
|
43 // Counts the given memory region in the given task/worker |
|
44 // counting data structures. |
|
45 inline void ConcurrentMark::count_region(MemRegion mr, HeapRegion* hr, |
|
46 size_t* marked_bytes_array, |
|
47 BitMap* task_card_bm) { |
|
48 G1CollectedHeap* g1h = _g1h; |
|
49 HeapWord* start = mr.start(); |
|
50 HeapWord* last = mr.last(); |
|
51 size_t region_size_bytes = mr.byte_size(); |
|
52 size_t index = hr->hrs_index(); |
|
53 |
|
54 assert(!hr->continuesHumongous(), "should not be HC region"); |
|
55 assert(hr == g1h->heap_region_containing(start), "sanity"); |
|
56 assert(hr == g1h->heap_region_containing(mr.last()), "sanity"); |
|
57 assert(marked_bytes_array != NULL, "pre-condition"); |
|
58 assert(task_card_bm != NULL, "pre-condition"); |
|
59 |
|
60 // Add to the task local marked bytes for this region. |
|
61 marked_bytes_array[index] += region_size_bytes; |
|
62 |
|
63 BitMap::idx_t start_idx = card_bitmap_index_for(start); |
|
64 BitMap::idx_t last_idx = card_bitmap_index_for(last); |
|
65 |
|
66 // The card bitmap is task/worker specific => no need to use 'par' routines. |
|
67 // Set bits in the inclusive bit range [start_idx, last_idx]. |
|
68 // |
|
69 // For small ranges use a simple loop; otherwise use set_range |
|
70 // The range are the cards that are spanned by the object/region |
|
71 // so 8 cards will allow objects/regions up to 4K to be handled |
|
72 // using the loop. |
|
73 if ((last_idx - start_idx) <= 8) { |
|
74 for (BitMap::idx_t i = start_idx; i <= last_idx; i += 1) { |
|
75 task_card_bm->set_bit(i); |
|
76 } |
|
77 } else { |
|
78 assert(last_idx < task_card_bm->size(), "sanity"); |
|
79 // Note: BitMap::set_range() is exclusive. |
|
80 task_card_bm->set_range(start_idx, last_idx+1); |
|
81 } |
|
82 } |
|
83 |
|
84 // Counts the given memory region, which may be a single object, in the |
|
85 // task/worker counting data structures for the given worker id. |
|
86 inline void ConcurrentMark::count_region(MemRegion mr, uint worker_id) { |
|
87 size_t* marked_bytes_array = count_marked_bytes_array_for(worker_id); |
|
88 BitMap* task_card_bm = count_card_bitmap_for(worker_id); |
|
89 HeapWord* addr = mr.start(); |
|
90 HeapRegion* hr = _g1h->heap_region_containing_raw(addr); |
|
91 count_region(mr, hr, marked_bytes_array, task_card_bm); |
|
92 } |
|
93 |
|
94 // Counts the given object in the given task/worker counting data structures. |
|
95 inline void ConcurrentMark::count_object(oop obj, |
|
96 HeapRegion* hr, |
|
97 size_t* marked_bytes_array, |
|
98 BitMap* task_card_bm) { |
|
99 MemRegion mr((HeapWord*)obj, obj->size()); |
|
100 count_region(mr, hr, marked_bytes_array, task_card_bm); |
|
101 } |
|
102 |
|
103 // Counts the given object in the task/worker counting data |
|
104 // structures for the given worker id. |
|
105 inline void ConcurrentMark::count_object(oop obj, HeapRegion* hr, uint worker_id) { |
|
106 size_t* marked_bytes_array = count_marked_bytes_array_for(worker_id); |
|
107 BitMap* task_card_bm = count_card_bitmap_for(worker_id); |
|
108 HeapWord* addr = (HeapWord*) obj; |
|
109 count_object(obj, hr, marked_bytes_array, task_card_bm); |
|
110 } |
|
111 |
|
112 // Attempts to mark the given object and, if successful, counts |
|
113 // the object in the given task/worker counting structures. |
|
114 inline bool ConcurrentMark::par_mark_and_count(oop obj, |
|
115 HeapRegion* hr, |
|
116 size_t* marked_bytes_array, |
|
117 BitMap* task_card_bm) { |
|
118 HeapWord* addr = (HeapWord*)obj; |
|
119 if (_nextMarkBitMap->parMark(addr)) { |
|
120 // Update the task specific count data for the object. |
|
121 count_object(obj, hr, marked_bytes_array, task_card_bm); |
|
122 return true; |
|
123 } |
|
124 return false; |
|
125 } |
|
126 |
|
127 // Attempts to mark the given object and, if successful, counts |
|
128 // the object in the task/worker counting structures for the |
|
129 // given worker id. |
|
130 inline bool ConcurrentMark::par_mark_and_count(oop obj, |
|
131 HeapRegion* hr, |
|
132 uint worker_id) { |
|
133 HeapWord* addr = (HeapWord*)obj; |
|
134 if (_nextMarkBitMap->parMark(addr)) { |
|
135 // Update the task specific count data for the object. |
|
136 count_object(obj, hr, worker_id); |
|
137 return true; |
|
138 } |
|
139 return false; |
|
140 } |
|
141 |
|
142 // As above - but we don't know the heap region containing the |
|
143 // object and so have to supply it. |
|
144 inline bool ConcurrentMark::par_mark_and_count(oop obj, uint worker_id) { |
|
145 HeapWord* addr = (HeapWord*)obj; |
|
146 HeapRegion* hr = _g1h->heap_region_containing_raw(addr); |
|
147 return par_mark_and_count(obj, hr, worker_id); |
|
148 } |
|
149 |
|
150 // Similar to the above routine but we already know the size, in words, of |
|
151 // the object that we wish to mark/count |
|
152 inline bool ConcurrentMark::par_mark_and_count(oop obj, |
|
153 size_t word_size, |
|
154 uint worker_id) { |
|
155 HeapWord* addr = (HeapWord*)obj; |
|
156 if (_nextMarkBitMap->parMark(addr)) { |
|
157 // Update the task specific count data for the object. |
|
158 MemRegion mr(addr, word_size); |
|
159 count_region(mr, worker_id); |
|
160 return true; |
|
161 } |
|
162 return false; |
|
163 } |
|
164 |
|
165 // Unconditionally mark the given object, and unconditinally count |
|
166 // the object in the counting structures for worker id 0. |
|
167 // Should *not* be called from parallel code. |
|
168 inline bool ConcurrentMark::mark_and_count(oop obj, HeapRegion* hr) { |
|
169 HeapWord* addr = (HeapWord*)obj; |
|
170 _nextMarkBitMap->mark(addr); |
|
171 // Update the task specific count data for the object. |
|
172 count_object(obj, hr, 0 /* worker_id */); |
|
173 return true; |
|
174 } |
|
175 |
|
176 // As above - but we don't have the heap region containing the |
|
177 // object, so we have to supply it. |
|
178 inline bool ConcurrentMark::mark_and_count(oop obj) { |
|
179 HeapWord* addr = (HeapWord*)obj; |
|
180 HeapRegion* hr = _g1h->heap_region_containing_raw(addr); |
|
181 return mark_and_count(obj, hr); |
|
182 } |
30 |
183 |
31 inline bool CMBitMapRO::iterate(BitMapClosure* cl, MemRegion mr) { |
184 inline bool CMBitMapRO::iterate(BitMapClosure* cl, MemRegion mr) { |
32 HeapWord* start_addr = MAX2(startWord(), mr.start()); |
185 HeapWord* start_addr = MAX2(startWord(), mr.start()); |
33 HeapWord* end_addr = MIN2(endWord(), mr.end()); |
186 HeapWord* end_addr = MIN2(endWord(), mr.end()); |
34 |
187 |