1 /*
2 * Copyright (c) 2005, 2026, Oracle and/or its affiliates. All rights reserved.
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 #include "classfile/classLoaderDataGraph.hpp"
26 #include "classfile/javaClasses.inline.hpp"
27 #include "classfile/stringTable.hpp"
28 #include "classfile/symbolTable.hpp"
29 #include "classfile/systemDictionary.hpp"
30 #include "code/codeCache.hpp"
31 #include "code/nmethod.hpp"
32 #include "compiler/oopMap.hpp"
33 #include "cppstdlib/new.hpp"
34 #include "gc/parallel/objectStartArray.inline.hpp"
35 #include "gc/parallel/parallelArguments.hpp"
36 #include "gc/parallel/parallelScavengeHeap.inline.hpp"
37 #include "gc/parallel/parMarkBitMap.inline.hpp"
38 #include "gc/parallel/psAdaptiveSizePolicy.hpp"
39 #include "gc/parallel/psCompactionManager.inline.hpp"
40 #include "gc/parallel/psOldGen.hpp"
41 #include "gc/parallel/psParallelCompact.inline.hpp"
42 #include "gc/parallel/psPromotionManager.inline.hpp"
43 #include "gc/parallel/psRootType.hpp"
44 #include "gc/parallel/psScavenge.hpp"
45 #include "gc/parallel/psStringDedup.hpp"
46 #include "gc/parallel/psYoungGen.hpp"
47 #include "gc/shared/classUnloadingContext.hpp"
48 #include "gc/shared/collectedHeap.inline.hpp"
49 #include "gc/shared/fullGCForwarding.inline.hpp"
50 #include "gc/shared/gcCause.hpp"
51 #include "gc/shared/gcHeapSummary.hpp"
52 #include "gc/shared/gcId.hpp"
53 #include "gc/shared/gcLocker.hpp"
54 #include "gc/shared/gcTimer.hpp"
55 #include "gc/shared/gcTrace.hpp"
56 #include "gc/shared/gcTraceTime.inline.hpp"
57 #include "gc/shared/gcVMOperations.hpp"
58 #include "gc/shared/isGCActiveMark.hpp"
59 #include "gc/shared/oopStorage.inline.hpp"
60 #include "gc/shared/oopStorageSet.inline.hpp"
61 #include "gc/shared/oopStorageSetParState.inline.hpp"
62 #include "gc/shared/parallelCleaning.hpp"
63 #include "gc/shared/preservedMarks.inline.hpp"
64 #include "gc/shared/referencePolicy.hpp"
65 #include "gc/shared/referenceProcessor.hpp"
66 #include "gc/shared/referenceProcessorPhaseTimes.hpp"
67 #include "gc/shared/spaceDecorator.hpp"
68 #include "gc/shared/taskTerminator.hpp"
69 #include "gc/shared/weakProcessor.inline.hpp"
70 #include "gc/shared/workerPolicy.hpp"
71 #include "gc/shared/workerThread.hpp"
72 #include "gc/shared/workerUtils.hpp"
73 #include "logging/log.hpp"
74 #include "memory/iterator.inline.hpp"
75 #include "memory/memoryReserver.hpp"
76 #include "memory/metaspaceUtils.hpp"
77 #include "memory/resourceArea.hpp"
78 #include "memory/universe.hpp"
79 #include "nmt/memTracker.hpp"
80 #include "oops/access.inline.hpp"
81 #include "oops/instanceClassLoaderKlass.inline.hpp"
82 #include "oops/instanceKlass.inline.hpp"
83 #include "oops/instanceMirrorKlass.inline.hpp"
84 #include "oops/methodData.hpp"
85 #include "oops/objArrayKlass.inline.hpp"
86 #include "oops/oop.inline.hpp"
87 #include "runtime/handles.inline.hpp"
88 #include "runtime/java.hpp"
89 #include "runtime/safepoint.hpp"
90 #include "runtime/threads.hpp"
91 #include "runtime/vmThread.hpp"
92 #include "services/memoryService.hpp"
93 #include "utilities/align.hpp"
94 #include "utilities/debug.hpp"
95 #include "utilities/events.hpp"
96 #include "utilities/formatBuffer.hpp"
97 #include "utilities/macros.hpp"
98 #include "utilities/stack.inline.hpp"
99 #if INCLUDE_JVMCI
100 #include "jvmci/jvmci.hpp"
101 #endif
102
103 #include <math.h>
104
105 // All sizes are in HeapWords.
106 const size_t ParallelCompactData::Log2RegionSize = 16; // 64K words
107 const size_t ParallelCompactData::RegionSize = (size_t)1 << Log2RegionSize;
108 static_assert(ParallelCompactData::RegionSize >= BitsPerWord, "region-start bit word-aligned");
109 const size_t ParallelCompactData::RegionSizeBytes =
110 RegionSize << LogHeapWordSize;
111 const size_t ParallelCompactData::RegionSizeOffsetMask = RegionSize - 1;
112 const size_t ParallelCompactData::RegionAddrOffsetMask = RegionSizeBytes - 1;
113 const size_t ParallelCompactData::RegionAddrMask = ~RegionAddrOffsetMask;
114
115 const ParallelCompactData::RegionData::region_sz_t
116 ParallelCompactData::RegionData::dc_shift = 27;
117
118 const ParallelCompactData::RegionData::region_sz_t
119 ParallelCompactData::RegionData::dc_mask = ~0U << dc_shift;
120
121 const ParallelCompactData::RegionData::region_sz_t
122 ParallelCompactData::RegionData::dc_one = 0x1U << dc_shift;
123
124 const ParallelCompactData::RegionData::region_sz_t
125 ParallelCompactData::RegionData::los_mask = ~dc_mask;
126
127 const ParallelCompactData::RegionData::region_sz_t
128 ParallelCompactData::RegionData::dc_claimed = 0x8U << dc_shift;
129
130 const ParallelCompactData::RegionData::region_sz_t
131 ParallelCompactData::RegionData::dc_completed = 0xcU << dc_shift;
132
133 bool ParallelCompactData::RegionData::is_clear() {
134 return (_destination == nullptr) &&
135 (_source_region == 0) &&
136 (_partial_obj_addr == nullptr) &&
137 (_partial_obj_size == 0) &&
138 (dc_and_los() == 0) &&
139 (shadow_state() == 0);
140 }
141
142 #ifdef ASSERT
143 void ParallelCompactData::RegionData::verify_clear() {
144 assert(_destination == nullptr, "inv");
145 assert(_source_region == 0, "inv");
146 assert(_partial_obj_addr == nullptr, "inv");
147 assert(_partial_obj_size == 0, "inv");
148 assert(dc_and_los() == 0, "inv");
149 assert(shadow_state() == 0, "inv");
150 }
151 #endif
152
153 SpaceInfo PSParallelCompact::_space_info[PSParallelCompact::last_space_id];
154
155 SpanSubjectToDiscoveryClosure PSParallelCompact::_span_based_discoverer;
156 ReferenceProcessor* PSParallelCompact::_ref_processor = nullptr;
157
158 void SplitInfo::record(size_t split_region_idx, HeapWord* split_point, size_t preceding_live_words) {
159 assert(split_region_idx != 0, "precondition");
160
161 // Obj denoted by split_point will be deferred to the next space.
162 assert(split_point != nullptr, "precondition");
163
164 const ParallelCompactData& sd = PSParallelCompact::summary_data();
165
166 PSParallelCompact::RegionData* split_region_ptr = sd.region(split_region_idx);
167 assert(preceding_live_words < split_region_ptr->data_size(), "inv");
168
169 HeapWord* preceding_destination = split_region_ptr->destination();
170 assert(preceding_destination != nullptr, "inv");
171
172 // How many regions does the preceding part occupy
173 uint preceding_destination_count;
174 if (preceding_live_words == 0) {
175 preceding_destination_count = 0;
176 } else {
177 // -1 so that the ending address doesn't fall on the region-boundary
178 if (sd.region_align_down(preceding_destination) ==
179 sd.region_align_down(preceding_destination + preceding_live_words - 1)) {
180 preceding_destination_count = 1;
181 } else {
182 preceding_destination_count = 2;
183 }
184 }
185
186 _split_region_idx = split_region_idx;
187 _split_point = split_point;
188 _preceding_live_words = preceding_live_words;
189 _preceding_destination = preceding_destination;
190 _preceding_destination_count = preceding_destination_count;
191 }
192
193 void SplitInfo::clear()
194 {
195 _split_region_idx = 0;
196 _split_point = nullptr;
197 _preceding_live_words = 0;
198 _preceding_destination = nullptr;
199 _preceding_destination_count = 0;
200 assert(!is_valid(), "sanity");
201 }
202
203 #ifdef ASSERT
204 void SplitInfo::verify_clear()
205 {
206 assert(_split_region_idx == 0, "not clear");
207 assert(_split_point == nullptr, "not clear");
208 assert(_preceding_live_words == 0, "not clear");
209 assert(_preceding_destination == nullptr, "not clear");
210 assert(_preceding_destination_count == 0, "not clear");
211 }
212 #endif // #ifdef ASSERT
213
214
215 void PSParallelCompact::print_on(outputStream* st) {
216 _mark_bitmap.print_on(st);
217 }
218
219 ParallelCompactData::ParallelCompactData() :
220 _heap_start(nullptr),
221 DEBUG_ONLY(_heap_end(nullptr) COMMA)
222 _region_vspace(nullptr),
223 _reserved_byte_size(0),
224 _region_data(nullptr),
225 _region_count(0) {}
226
227 bool ParallelCompactData::initialize(MemRegion reserved_heap)
228 {
229 _heap_start = reserved_heap.start();
230 const size_t heap_size = reserved_heap.word_size();
231 DEBUG_ONLY(_heap_end = _heap_start + heap_size;)
232
233 assert(region_align_down(_heap_start) == _heap_start,
234 "region start not aligned");
235
236 return initialize_region_data(heap_size);
237 }
238
239 PSVirtualSpace*
240 ParallelCompactData::create_vspace(size_t count, size_t element_size)
241 {
242 const size_t raw_bytes = count * element_size;
243 const size_t page_sz = os::page_size_for_region_aligned(raw_bytes, 10);
244 const size_t granularity = os::vm_allocation_granularity();
245 const size_t rs_align = MAX2(page_sz, granularity);
246
247 _reserved_byte_size = align_up(raw_bytes, rs_align);
248
249 ReservedSpace rs = MemoryReserver::reserve(_reserved_byte_size,
250 rs_align,
251 page_sz,
252 mtGC);
253
254 if (!rs.is_reserved()) {
255 // Failed to reserve memory.
256 return nullptr;
257 }
258
259 os::trace_page_sizes("Parallel Compact Data", raw_bytes, raw_bytes, rs.base(),
260 rs.size(), page_sz);
261
262 MemTracker::record_virtual_memory_tag(rs, mtGC);
263
264 PSVirtualSpace* vspace = new PSVirtualSpace(rs, page_sz);
265
266 if (!vspace->expand_by(_reserved_byte_size)) {
267 // Failed to commit memory.
268
269 delete vspace;
270
271 // Release memory reserved in the space.
272 MemoryReserver::release(rs);
273
274 return nullptr;
275 }
276
277 return vspace;
278 }
279
280 bool ParallelCompactData::initialize_region_data(size_t heap_size)
281 {
282 assert(is_aligned(heap_size, RegionSize), "precondition");
283
284 const size_t count = heap_size >> Log2RegionSize;
285 _region_vspace = create_vspace(count, sizeof(RegionData));
286 if (_region_vspace != nullptr) {
287 _region_data = (RegionData*)_region_vspace->reserved_low_addr();
288 _region_count = count;
289 return true;
290 }
291 return false;
292 }
293
294 void ParallelCompactData::clear_range(size_t beg_region, size_t end_region) {
295 assert(beg_region <= _region_count, "beg_region out of range");
296 assert(end_region <= _region_count, "end_region out of range");
297
298 const size_t region_cnt = end_region - beg_region;
299 for (size_t i = beg_region; i < end_region; i++) {
300 ::new (&_region_data[i]) RegionData{};
301 }
302 }
303
304 // The total live words on src_region would overflow the target space, so find
305 // the overflowing object and record the split point. The invariant is that an
306 // obj should not cross space boundary.
307 HeapWord* ParallelCompactData::summarize_split_space(size_t src_region,
308 SplitInfo& split_info,
309 HeapWord* const destination,
310 HeapWord* const target_end,
311 HeapWord** target_next) {
312 assert(destination <= target_end, "sanity");
313 assert(destination + _region_data[src_region].data_size() > target_end,
314 "region should not fit into target space");
315 assert(is_region_aligned(target_end), "sanity");
316
317 size_t partial_obj_size = _region_data[src_region].partial_obj_size();
318
319 if (destination + partial_obj_size > target_end) {
320 assert(partial_obj_size > 0, "inv");
321 // The overflowing obj is from a previous region.
322 //
323 // source-regions:
324 //
325 // ***************
326 // | A|AA |
327 // ***************
328 // ^
329 // | split-point
330 //
331 // dest-region:
332 //
333 // ********
334 // |~~~~A |
335 // ********
336 // ^^
337 // || target-space-end
338 // |
339 // | destination
340 //
341 // AAA would overflow target-space.
342 //
343 HeapWord* overflowing_obj = _region_data[src_region].partial_obj_addr();
344 size_t split_region = addr_to_region_idx(overflowing_obj);
345
346 // The number of live words before the overflowing object on this split region
347 size_t preceding_live_words;
348 if (is_region_aligned(overflowing_obj)) {
349 preceding_live_words = 0;
350 } else {
351 // Words accounted by the overflowing object on the split region
352 size_t overflowing_size = pointer_delta(region_align_up(overflowing_obj), overflowing_obj);
353 preceding_live_words = region(split_region)->data_size() - overflowing_size;
354 }
355
356 split_info.record(split_region, overflowing_obj, preceding_live_words);
357
358 // The [overflowing_obj, src_region_start) part has been accounted for, so
359 // must move back the new_top, now that this overflowing obj is deferred.
360 HeapWord* new_top = destination - pointer_delta(region_to_addr(src_region), overflowing_obj);
361
362 // If the overflowing obj was relocated to its original destination,
363 // those destination regions would have their source_region set. Now that
364 // this overflowing obj is relocated somewhere else, reset the
365 // source_region.
366 {
367 size_t range_start = addr_to_region_idx(region_align_up(new_top));
368 size_t range_end = addr_to_region_idx(region_align_up(destination));
369 for (size_t i = range_start; i < range_end; ++i) {
370 region(i)->set_source_region(0);
371 }
372 }
373
374 // Update new top of target space
375 *target_next = new_top;
376
377 return overflowing_obj;
378 }
379
380 // Obj-iteration to locate the overflowing obj
381 HeapWord* region_start = region_to_addr(src_region);
382 HeapWord* region_end = region_start + RegionSize;
383 HeapWord* cur_addr = region_start + partial_obj_size;
384 size_t live_words = partial_obj_size;
385
386 while (true) {
387 assert(cur_addr < region_end, "inv");
388 cur_addr = PSParallelCompact::mark_bitmap()->find_obj_beg(cur_addr, region_end);
389 // There must be an overflowing obj in this region
390 assert(cur_addr < region_end, "inv");
391
392 oop obj = cast_to_oop(cur_addr);
393 size_t obj_size = obj->size();
394 if (destination + live_words + obj_size > target_end) {
395 // Found the overflowing obj
396 split_info.record(src_region, cur_addr, live_words);
397 *target_next = destination + live_words;
398 return cur_addr;
399 }
400
401 live_words += obj_size;
402 cur_addr += obj_size;
403 }
404 }
405
406 size_t ParallelCompactData::live_words_in_space(const MutableSpace* space,
407 HeapWord** full_region_prefix_end) {
408 size_t cur_region = addr_to_region_idx(space->bottom());
409 const size_t end_region = addr_to_region_idx(region_align_up(space->top()));
410 size_t live_words = 0;
411 if (full_region_prefix_end == nullptr) {
412 for (/* empty */; cur_region < end_region; ++cur_region) {
413 live_words += _region_data[cur_region].data_size();
414 }
415 } else {
416 bool first_set = false;
417 for (/* empty */; cur_region < end_region; ++cur_region) {
418 size_t live_words_in_region = _region_data[cur_region].data_size();
419 if (!first_set && live_words_in_region < RegionSize) {
420 *full_region_prefix_end = region_to_addr(cur_region);
421 first_set = true;
422 }
423 live_words += live_words_in_region;
424 }
425 if (!first_set) {
426 // All regions are full of live objs.
427 assert(is_region_aligned(space->top()), "inv");
428 *full_region_prefix_end = space->top();
429 }
430 assert(*full_region_prefix_end != nullptr, "postcondition");
431 assert(is_region_aligned(*full_region_prefix_end), "inv");
432 assert(*full_region_prefix_end >= space->bottom(), "in-range");
433 assert(*full_region_prefix_end <= space->top(), "in-range");
434 }
435 return live_words;
436 }
437
438 bool ParallelCompactData::summarize(SplitInfo& split_info,
439 HeapWord* source_beg, HeapWord* source_end,
440 HeapWord** source_next,
441 HeapWord* target_beg, HeapWord* target_end,
442 HeapWord** target_next)
443 {
444 HeapWord* const source_next_val = source_next == nullptr ? nullptr : *source_next;
445 log_develop_trace(gc, compaction)(
446 "sb=" PTR_FORMAT " se=" PTR_FORMAT " sn=" PTR_FORMAT
447 "tb=" PTR_FORMAT " te=" PTR_FORMAT " tn=" PTR_FORMAT,
448 p2i(source_beg), p2i(source_end), p2i(source_next_val),
449 p2i(target_beg), p2i(target_end), p2i(*target_next));
450
451 size_t cur_region = addr_to_region_idx(source_beg);
452 const size_t end_region = addr_to_region_idx(region_align_up(source_end));
453
454 HeapWord *dest_addr = target_beg;
455 for (/* empty */; cur_region < end_region; cur_region++) {
456 size_t words = _region_data[cur_region].data_size();
457
458 // Skip empty ones
459 if (words == 0) {
460 continue;
461 }
462
463 if (split_info.is_split(cur_region)) {
464 assert(words > split_info.preceding_live_words(), "inv");
465 words -= split_info.preceding_live_words();
466 }
467
468 _region_data[cur_region].set_destination(dest_addr);
469
470 // If cur_region does not fit entirely into the target space, find a point
471 // at which the source space can be 'split' so that part is copied to the
472 // target space and the rest is copied elsewhere.
473 if (dest_addr + words > target_end) {
474 assert(source_next != nullptr, "source_next is null when splitting");
475 *source_next = summarize_split_space(cur_region, split_info, dest_addr,
476 target_end, target_next);
477 return false;
478 }
479
480 uint destination_count = split_info.is_split(cur_region)
481 ? split_info.preceding_destination_count()
482 : 0;
483
484 HeapWord* const last_addr = dest_addr + words - 1;
485 const size_t dest_region_1 = addr_to_region_idx(dest_addr);
486 const size_t dest_region_2 = addr_to_region_idx(last_addr);
487
488 // Initially assume that the destination regions will be the same and
489 // adjust the value below if necessary. Under this assumption, if
490 // cur_region == dest_region_2, then cur_region will be compacted
491 // completely into itself.
492 destination_count += cur_region == dest_region_2 ? 0 : 1;
493 if (dest_region_1 != dest_region_2) {
494 // Destination regions differ; adjust destination_count.
495 destination_count += 1;
496 // Data from cur_region will be copied to the start of dest_region_2.
497 _region_data[dest_region_2].set_source_region(cur_region);
498 } else if (is_region_aligned(dest_addr)) {
499 // Data from cur_region will be copied to the start of the destination
500 // region.
501 _region_data[dest_region_1].set_source_region(cur_region);
502 }
503
504 _region_data[cur_region].set_destination_count(destination_count);
505 dest_addr += words;
506 }
507
508 *target_next = dest_addr;
509 return true;
510 }
511
512 #ifdef ASSERT
513 void ParallelCompactData::verify_clear() {
514 for (uint cur_idx = 0; cur_idx < region_count(); ++cur_idx) {
515 if (!region(cur_idx)->is_clear()) {
516 log_warning(gc)("Uncleared Region: %u", cur_idx);
517 region(cur_idx)->verify_clear();
518 }
519 }
520 }
521 #endif // #ifdef ASSERT
522
523 STWGCTimer PSParallelCompact::_gc_timer;
524 ParallelOldTracer PSParallelCompact::_gc_tracer;
525 elapsedTimer PSParallelCompact::_accumulated_time;
526 unsigned int PSParallelCompact::_maximum_compaction_gc_num = 0;
527 CollectorCounters* PSParallelCompact::_counters = nullptr;
528 ParMarkBitMap PSParallelCompact::_mark_bitmap;
529 ParallelCompactData PSParallelCompact::_summary_data;
530
531 PSParallelCompact::IsAliveClosure PSParallelCompact::_is_alive_closure;
532
533 class PCAdjustPointerClosureNew: public BasicOopIterateClosure {
534 template <typename T>
535 void do_oop_work(T* p) { PSParallelCompact::adjust_pointer(p); }
536
537 public:
538 virtual void do_oop(oop* p) { do_oop_work(p); }
539 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
540
541 virtual ReferenceIterationMode reference_iteration_mode() { return DO_FIELDS; }
542 };
543
544 static PCAdjustPointerClosureNew pc_adjust_pointer_closure;
545
546 bool PSParallelCompact::IsAliveClosure::do_object_b(oop p) { return mark_bitmap()->is_marked(p); }
547
548 void PSParallelCompact::post_initialize() {
549 ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
550 _span_based_discoverer.set_span(heap->reserved_region());
551 _ref_processor =
552 new ReferenceProcessor(&_span_based_discoverer,
553 ParallelGCThreads, // mt processing degree
554 ParallelGCThreads, // mt discovery degree
555 false, // concurrent_discovery
556 &_is_alive_closure); // non-header is alive closure
557
558 _counters = new CollectorCounters("Parallel full collection pauses", 1);
559
560 // Initialize static fields in ParCompactionManager.
561 ParCompactionManager::initialize(mark_bitmap());
562 }
563
564 bool PSParallelCompact::initialize_aux_data() {
565 ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
566 MemRegion mr = heap->reserved_region();
567 assert(mr.byte_size() != 0, "heap should be reserved");
568
569 initialize_space_info();
570
571 if (!_mark_bitmap.initialize(mr)) {
572 vm_shutdown_during_initialization(
573 err_msg("Unable to allocate %zuKB bitmaps for parallel "
574 "garbage collection for the requested %zuKB heap.",
575 _mark_bitmap.reserved_byte_size()/K, mr.byte_size()/K));
576 return false;
577 }
578
579 if (!_summary_data.initialize(mr)) {
580 vm_shutdown_during_initialization(
581 err_msg("Unable to allocate %zuKB card tables for parallel "
582 "garbage collection for the requested %zuKB heap.",
583 _summary_data.reserved_byte_size()/K, mr.byte_size()/K));
584 return false;
585 }
586
587 return true;
588 }
589
590 void PSParallelCompact::initialize_space_info()
591 {
592 memset(&_space_info, 0, sizeof(_space_info));
593
594 ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
595 PSYoungGen* young_gen = heap->young_gen();
596
597 _space_info[old_space_id].set_space(heap->old_gen()->object_space());
598 _space_info[eden_space_id].set_space(young_gen->eden_space());
599 _space_info[from_space_id].set_space(young_gen->from_space());
600 _space_info[to_space_id].set_space(young_gen->to_space());
601
602 _space_info[old_space_id].set_start_array(heap->old_gen()->start_array());
603 }
604
605 void
606 PSParallelCompact::clear_data_covering_space(SpaceId id)
607 {
608 // At this point, top is the value before GC, new_top() is the value that will
609 // be set at the end of GC. The marking bitmap is cleared to top; nothing
610 // should be marked above top. The summary data is cleared to the larger of
611 // top & new_top.
612 MutableSpace* const space = _space_info[id].space();
613 HeapWord* const bot = space->bottom();
614 HeapWord* const top = space->top();
615 HeapWord* const max_top = MAX2(top, _space_info[id].new_top());
616
617 _mark_bitmap.clear_range(bot, top);
618
619 const size_t beg_region = _summary_data.addr_to_region_idx(bot);
620 const size_t end_region =
621 _summary_data.addr_to_region_idx(_summary_data.region_align_up(max_top));
622 _summary_data.clear_range(beg_region, end_region);
623
624 // Clear the data used to 'split' regions.
625 SplitInfo& split_info = _space_info[id].split_info();
626 if (split_info.is_valid()) {
627 split_info.clear();
628 }
629 DEBUG_ONLY(split_info.verify_clear();)
630 }
631
632 void PSParallelCompact::pre_compact()
633 {
634 // Update the from & to space pointers in space_info, since they are swapped
635 // at each young gen gc. Do the update unconditionally (even though a
636 // promotion failure does not swap spaces) because an unknown number of young
637 // collections will have swapped the spaces an unknown number of times.
638 GCTraceTime(Debug, gc, phases) tm("Pre Compact", &_gc_timer);
639 ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
640 _space_info[from_space_id].set_space(heap->young_gen()->from_space());
641 _space_info[to_space_id].set_space(heap->young_gen()->to_space());
642
643 heap->increment_total_collections(true);
644
645 CodeCache::on_gc_marking_cycle_start();
646
647 heap->print_before_gc();
648 heap->trace_heap_before_gc(&_gc_tracer);
649
650 // Fill in TLABs
651 heap->ensure_parsability(true); // retire TLABs
652
653 if (VerifyBeforeGC && heap->total_collections() >= VerifyGCStartAt) {
654 Universe::verify("Before GC");
655 }
656
657 DEBUG_ONLY(mark_bitmap()->verify_clear();)
658 DEBUG_ONLY(summary_data().verify_clear();)
659 }
660
661 void PSParallelCompact::post_compact()
662 {
663 GCTraceTime(Info, gc, phases) tm("Post Compact", &_gc_timer);
664 ParCompactionManager::remove_all_shadow_regions();
665
666 CodeCache::on_gc_marking_cycle_finish();
667 CodeCache::arm_all_nmethods();
668
669 // Need to clear claim bits for the next full-gc (marking and adjust-pointers).
670 ClassLoaderDataGraph::clear_claimed_marks();
671
672 for (unsigned int id = old_space_id; id < last_space_id; ++id) {
673 // Clear the marking bitmap, summary data and split info.
674 clear_data_covering_space(SpaceId(id));
675 {
676 MutableSpace* space = _space_info[id].space();
677 HeapWord* top = space->top();
678 HeapWord* new_top = _space_info[id].new_top();
679 if (ZapUnusedHeapArea && new_top < top) {
680 space->mangle_region(MemRegion(new_top, top));
681 }
682 // Update top(). Must be done after clearing the bitmap and summary data.
683 space->set_top(new_top);
684 }
685 }
686
687 #ifdef ASSERT
688 {
689 mark_bitmap()->verify_clear();
690 summary_data().verify_clear();
691 }
692 #endif
693
694 ParCompactionManager::flush_all_string_dedup_requests();
695
696 MutableSpace* const eden_space = _space_info[eden_space_id].space();
697 MutableSpace* const from_space = _space_info[from_space_id].space();
698 MutableSpace* const to_space = _space_info[to_space_id].space();
699
700 ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
701 bool eden_empty = eden_space->is_empty();
702
703 // Update heap occupancy information which is used as input to the soft ref
704 // clearing policy at the next gc.
705 Universe::heap()->update_capacity_and_used_at_gc();
706
707 bool young_gen_empty = eden_empty && from_space->is_empty() &&
708 to_space->is_empty();
709
710 PSCardTable* ct = heap->card_table();
711 MemRegion old_mr = heap->old_gen()->committed();
712 if (young_gen_empty) {
713 ct->clear_MemRegion(old_mr);
714 } else {
715 ct->dirty_MemRegion(old_mr);
716 }
717
718 heap->prune_scavengable_nmethods();
719
720 #if COMPILER2_OR_JVMCI
721 DerivedPointerTable::update_pointers();
722 #endif
723
724 // Signal that we have completed a visit to all live objects.
725 Universe::heap()->record_whole_heap_examined_timestamp();
726 }
727
728 HeapWord* PSParallelCompact::compute_dense_prefix_for_old_space(MutableSpace* old_space,
729 HeapWord* full_region_prefix_end) {
730 const size_t region_size = ParallelCompactData::RegionSize;
731 const ParallelCompactData& sd = summary_data();
732
733 // Iteration starts with the region *after* the full-region-prefix-end.
734 const RegionData* const start_region = sd.addr_to_region_ptr(full_region_prefix_end);
735 // If final region is not full, iteration stops before that region,
736 // because fill_dense_prefix_end assumes that prefix_end <= top.
737 const RegionData* const end_region = sd.addr_to_region_ptr(old_space->top());
738 assert(start_region <= end_region, "inv");
739
740 size_t max_waste = old_space->capacity_in_words() * (MarkSweepDeadRatio / 100.0);
741 const RegionData* cur_region = start_region;
742 for (/* empty */; cur_region < end_region; ++cur_region) {
743 assert(region_size >= cur_region->data_size(), "inv");
744 size_t dead_size = region_size - cur_region->data_size();
745 if (max_waste < dead_size) {
746 break;
747 }
748 max_waste -= dead_size;
749 }
750
751 HeapWord* const prefix_end = sd.region_to_addr(cur_region);
752 assert(sd.is_region_aligned(prefix_end), "postcondition");
753 assert(prefix_end >= full_region_prefix_end, "in-range");
754 assert(prefix_end <= old_space->top(), "in-range");
755 return prefix_end;
756 }
757
758 void PSParallelCompact::fill_dense_prefix_end(SpaceId id) {
759 // Comparing two sizes to decide if filling is required:
760 //
761 // The size of the filler (min-obj-size) is 2 heap words with the default
762 // MinObjAlignment, since both markword and klass take 1 heap word.
763 // With +UseCompactObjectHeaders, the minimum filler size is only one word,
764 // because the Klass* gets encoded in the mark-word.
765 //
766 // The size of the gap (if any) right before dense-prefix-end is
767 // MinObjAlignment.
768 //
769 // Need to fill in the gap only if it's smaller than min-obj-size, and the
770 // filler obj will extend to next region.
771
772 if (MinObjAlignment >= checked_cast<int>(CollectedHeap::min_fill_size())) {
773 return;
774 }
775
776 assert(!UseCompactObjectHeaders, "Compact headers can allocate small objects");
777 assert(CollectedHeap::min_fill_size() == 2, "inv");
778 HeapWord* const dense_prefix_end = dense_prefix(id);
779 assert(_summary_data.is_region_aligned(dense_prefix_end), "precondition");
780 assert(dense_prefix_end <= space(id)->top(), "precondition");
781 if (dense_prefix_end == space(id)->top()) {
782 // Must not have single-word gap right before prefix-end/top.
783 return;
784 }
785 RegionData* const region_after_dense_prefix = _summary_data.addr_to_region_ptr(dense_prefix_end);
786
787 if (region_after_dense_prefix->partial_obj_size() != 0 ||
788 _mark_bitmap.is_marked(dense_prefix_end)) {
789 // The region after the dense prefix starts with live bytes.
790 return;
791 }
792
793 HeapWord* block_start = start_array(id)->block_start_reaching_into_card(dense_prefix_end);
794 if (block_start == dense_prefix_end - 1) {
795 assert(!_mark_bitmap.is_marked(block_start), "inv");
796 // There is exactly one heap word gap right before the dense prefix end, so we need a filler object.
797 // The filler object will extend into region_after_dense_prefix.
798 const size_t obj_len = 2; // min-fill-size
799 HeapWord* const obj_beg = dense_prefix_end - 1;
800 CollectedHeap::fill_with_object(obj_beg, obj_len);
801 _mark_bitmap.mark_obj(obj_beg);
802 _summary_data.addr_to_region_ptr(obj_beg)->add_live_obj(1);
803 region_after_dense_prefix->set_partial_obj_size(1);
804 region_after_dense_prefix->set_partial_obj_addr(obj_beg);
805 assert(start_array(id) != nullptr, "sanity");
806 start_array(id)->update_for_block(obj_beg, obj_beg + obj_len);
807 }
808 }
809
810 bool PSParallelCompact::check_maximum_compaction(bool should_do_max_compaction,
811 size_t total_live_words,
812 MutableSpace* const old_space,
813 HeapWord* full_region_prefix_end) {
814
815 ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
816
817 // Check System.GC
818 bool is_max_on_system_gc = UseMaximumCompactionOnSystemGC
819 && GCCause::is_user_requested_gc(heap->gc_cause());
820
821 // Check if all live objs are too much for old-gen.
822 const bool is_old_gen_too_full = (total_live_words >= old_space->capacity_in_words());
823
824 // If all regions in old-gen are full
825 const bool is_region_full =
826 full_region_prefix_end >= _summary_data.region_align_down(old_space->top());
827
828 return should_do_max_compaction
829 || is_max_on_system_gc
830 || is_old_gen_too_full
831 || is_region_full;
832 }
833
834 void PSParallelCompact::summary_phase(bool should_do_max_compaction)
835 {
836 GCTraceTime(Info, gc, phases) tm("Summary Phase", &_gc_timer);
837
838 MutableSpace* const old_space = _space_info[old_space_id].space();
839 {
840 size_t total_live_words = 0;
841 HeapWord* full_region_prefix_end = nullptr;
842 {
843 // old-gen
844 size_t live_words = _summary_data.live_words_in_space(old_space,
845 &full_region_prefix_end);
846 total_live_words += live_words;
847 }
848 // young-gen
849 for (uint i = eden_space_id; i < last_space_id; ++i) {
850 const MutableSpace* space = _space_info[i].space();
851 size_t live_words = _summary_data.live_words_in_space(space);
852 total_live_words += live_words;
853 _space_info[i].set_new_top(space->bottom() + live_words);
854 _space_info[i].set_dense_prefix(space->bottom());
855 }
856
857 should_do_max_compaction = check_maximum_compaction(should_do_max_compaction,
858 total_live_words,
859 old_space,
860 full_region_prefix_end);
861 {
862 GCTraceTime(Info, gc, phases) tm("Summary Phase: expand", &_gc_timer);
863 // Try to expand old-gen in order to fit all live objs and waste.
864 size_t target_capacity_bytes = total_live_words * HeapWordSize
865 + old_space->capacity_in_bytes() * (MarkSweepDeadRatio / 100);
866 ParallelScavengeHeap::heap()->old_gen()->try_expand_till_size(target_capacity_bytes);
867 }
868
869 HeapWord* dense_prefix_end = should_do_max_compaction
870 ? full_region_prefix_end
871 : compute_dense_prefix_for_old_space(old_space,
872 full_region_prefix_end);
873 SpaceId id = old_space_id;
874 _space_info[id].set_dense_prefix(dense_prefix_end);
875
876 if (dense_prefix_end != old_space->bottom()) {
877 fill_dense_prefix_end(id);
878 }
879
880 // Compacting objs in [dense_prefix_end, old_space->top())
881 _summary_data.summarize(_space_info[id].split_info(),
882 dense_prefix_end, old_space->top(), nullptr,
883 dense_prefix_end, old_space->end(),
884 _space_info[id].new_top_addr());
885 }
886
887 // Summarize the remaining spaces in the young gen. The initial target space
888 // is the old gen. If a space does not fit entirely into the target, then the
889 // remainder is compacted into the space itself and that space becomes the new
890 // target.
891 SpaceId dst_space_id = old_space_id;
892 HeapWord* dst_space_end = old_space->end();
893 HeapWord** new_top_addr = _space_info[dst_space_id].new_top_addr();
894 for (unsigned int id = eden_space_id; id < last_space_id; ++id) {
895 const MutableSpace* space = _space_info[id].space();
896 const size_t live = pointer_delta(_space_info[id].new_top(),
897 space->bottom());
898 const size_t available = pointer_delta(dst_space_end, *new_top_addr);
899
900 if (live > 0 && live <= available) {
901 // All the live data will fit.
902 bool done = _summary_data.summarize(_space_info[id].split_info(),
903 space->bottom(), space->top(),
904 nullptr,
905 *new_top_addr, dst_space_end,
906 new_top_addr);
907 assert(done, "space must fit into old gen");
908
909 // Reset the new_top value for the space.
910 _space_info[id].set_new_top(space->bottom());
911 } else if (live > 0) {
912 // Attempt to fit part of the source space into the target space.
913 HeapWord* next_src_addr = nullptr;
914 bool done = _summary_data.summarize(_space_info[id].split_info(),
915 space->bottom(), space->top(),
916 &next_src_addr,
917 *new_top_addr, dst_space_end,
918 new_top_addr);
919 assert(!done, "space should not fit into old gen");
920 assert(next_src_addr != nullptr, "sanity");
921
922 // The source space becomes the new target, so the remainder is compacted
923 // within the space itself.
924 dst_space_id = SpaceId(id);
925 dst_space_end = space->end();
926 new_top_addr = _space_info[id].new_top_addr();
927 done = _summary_data.summarize(_space_info[id].split_info(),
928 next_src_addr, space->top(),
929 nullptr,
930 space->bottom(), dst_space_end,
931 new_top_addr);
932 assert(done, "space must fit when compacted into itself");
933 assert(*new_top_addr <= space->top(), "usage should not grow");
934 }
935 }
936 }
937
938 void PSParallelCompact::report_object_count_after_gc() {
939 GCTraceTime(Debug, gc, phases) tm("Report Object Count", &_gc_timer);
940 // The heap is compacted, all objects are iterable. However there may be
941 // filler objects in the heap which we should ignore.
942 class SkipFillerObjectClosure : public BoolObjectClosure {
943 public:
944 bool do_object_b(oop obj) override { return !CollectedHeap::is_filler_object(obj); }
945 } cl;
946 _gc_tracer.report_object_count_after_gc(&cl, &ParallelScavengeHeap::heap()->workers());
947 }
948
949 bool PSParallelCompact::invoke(bool clear_all_soft_refs, bool should_do_max_compaction) {
950 assert(SafepointSynchronize::is_at_safepoint(), "should be at safepoint");
951 assert(Thread::current() == (Thread*)VMThread::vm_thread(),
952 "should be in vm thread");
953 assert(ref_processor() != nullptr, "Sanity");
954
955 SvcGCMarker sgcm(SvcGCMarker::FULL);
956 IsSTWGCActiveMark mark;
957
958 ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
959
960 GCIdMark gc_id_mark;
961 _gc_timer.register_gc_start();
962 _gc_tracer.report_gc_start(heap->gc_cause(), _gc_timer.gc_start());
963
964 GCCause::Cause gc_cause = heap->gc_cause();
965 PSOldGen* old_gen = heap->old_gen();
966 PSAdaptiveSizePolicy* size_policy = heap->size_policy();
967
968 // Make sure data structures are sane, make the heap parsable, and do other
969 // miscellaneous bookkeeping.
970 pre_compact();
971
972 const PreGenGCValues pre_gc_values = heap->get_pre_gc_values();
973
974 {
975 const uint active_workers =
976 WorkerPolicy::calc_active_workers(ParallelScavengeHeap::heap()->workers().max_workers(),
977 ParallelScavengeHeap::heap()->workers().active_workers(),
978 Threads::number_of_non_daemon_threads());
979 ParallelScavengeHeap::heap()->workers().set_active_workers(active_workers);
980
981 GCTraceCPUTime tcpu(&_gc_tracer);
982 GCTraceTime(Info, gc) tm("Pause Full", nullptr, gc_cause, true);
983
984 heap->pre_full_gc_dump(&_gc_timer);
985
986 TraceCollectorStats tcs(counters());
987 TraceMemoryManagerStats tms(heap->old_gc_manager(), gc_cause, "end of major GC");
988
989 if (log_is_enabled(Debug, gc, heap, exit)) {
990 accumulated_time()->start();
991 }
992
993 // Let the size policy know we're starting
994 size_policy->major_collection_begin();
995
996 #if COMPILER2_OR_JVMCI
997 DerivedPointerTable::clear();
998 #endif
999
1000 ref_processor()->start_discovery(clear_all_soft_refs);
1001
1002 marking_phase(&_gc_tracer);
1003
1004 summary_phase(should_do_max_compaction);
1005
1006 #if COMPILER2_OR_JVMCI
1007 assert(DerivedPointerTable::is_active(), "Sanity");
1008 DerivedPointerTable::set_active(false);
1009 #endif
1010
1011 FullGCForwarding::begin();
1012
1013 forward_to_new_addr();
1014
1015 adjust_pointers();
1016
1017 compact();
1018
1019 FullGCForwarding::end();
1020
1021 ParCompactionManager::_preserved_marks_set->restore(&ParallelScavengeHeap::heap()->workers());
1022
1023 ParCompactionManager::verify_all_region_stack_empty();
1024
1025 // Reset the mark bitmap, summary data, and do other bookkeeping. Must be
1026 // done before resizing.
1027 post_compact();
1028
1029 size_policy->major_collection_end();
1030
1031 size_policy->sample_old_gen_used_bytes(MAX2(pre_gc_values.old_gen_used(), old_gen->used_in_bytes()));
1032
1033 if (UseAdaptiveSizePolicy) {
1034 heap->resize_after_full_gc();
1035 }
1036
1037 heap->resize_all_tlabs();
1038
1039 // Resize the metaspace capacity after a collection
1040 MetaspaceGC::compute_new_size();
1041
1042 if (log_is_enabled(Debug, gc, heap, exit)) {
1043 accumulated_time()->stop();
1044 }
1045
1046 heap->print_heap_change(pre_gc_values);
1047
1048 report_object_count_after_gc();
1049
1050 // Track memory usage and detect low memory
1051 MemoryService::track_memory_usage();
1052 heap->update_counters();
1053
1054 heap->post_full_gc_dump(&_gc_timer);
1055
1056 size_policy->record_gc_pause_end_instant();
1057 }
1058
1059 heap->gc_epilogue(true);
1060
1061 if (VerifyAfterGC && heap->total_collections() >= VerifyGCStartAt) {
1062 Universe::verify("After GC");
1063 }
1064
1065 heap->print_after_gc();
1066 heap->trace_heap_after_gc(&_gc_tracer);
1067
1068 _gc_timer.register_gc_end();
1069
1070 _gc_tracer.report_dense_prefix(dense_prefix(old_space_id));
1071 _gc_tracer.report_gc_end(_gc_timer.gc_end(), _gc_timer.time_partitions());
1072
1073 return true;
1074 }
1075
1076 class PCAddThreadRootsMarkingTaskClosure : public ThreadClosure {
1077 ParCompactionManager* _cm;
1078
1079 public:
1080 PCAddThreadRootsMarkingTaskClosure(ParCompactionManager* cm) : _cm(cm) { }
1081 void do_thread(Thread* thread) {
1082 ResourceMark rm;
1083
1084 MarkingNMethodClosure mark_and_push_in_blobs(&_cm->_mark_and_push_closure);
1085
1086 thread->oops_do(&_cm->_mark_and_push_closure, &mark_and_push_in_blobs);
1087
1088 // Do the real work
1089 _cm->follow_marking_stacks();
1090 }
1091 };
1092
1093 void steal_marking_work(TaskTerminator& terminator, uint worker_id) {
1094 assert(ParallelScavengeHeap::heap()->is_stw_gc_active(), "called outside gc");
1095
1096 ParCompactionManager* cm =
1097 ParCompactionManager::gc_thread_compaction_manager(worker_id);
1098
1099 do {
1100 ScannerTask task;
1101 if (ParCompactionManager::steal(worker_id, task)) {
1102 cm->follow_contents(task, true);
1103 }
1104 cm->follow_marking_stacks();
1105 } while (!terminator.offer_termination());
1106 }
1107
1108 class MarkFromRootsTask : public WorkerTask {
1109 NMethodMarkingScope _nmethod_marking_scope;
1110 ThreadsClaimTokenScope _threads_claim_token_scope;
1111 OopStorageSetStrongParState<false /* concurrent */, false /* is_const */> _oop_storage_set_par_state;
1112 TaskTerminator _terminator;
1113 uint _active_workers;
1114
1115 public:
1116 MarkFromRootsTask(uint active_workers) :
1117 WorkerTask("MarkFromRootsTask"),
1118 _nmethod_marking_scope(),
1119 _threads_claim_token_scope(),
1120 _terminator(active_workers, ParCompactionManager::marking_stacks()),
1121 _active_workers(active_workers) {}
1122
1123 virtual void work(uint worker_id) {
1124 ParCompactionManager* cm = ParCompactionManager::gc_thread_compaction_manager(worker_id);
1125 cm->create_marking_stats_cache();
1126 {
1127 CLDToOopClosure cld_closure(&cm->_mark_and_push_closure, ClassLoaderData::_claim_stw_fullgc_mark);
1128 ClassLoaderDataGraph::always_strong_cld_do(&cld_closure);
1129
1130 // Do the real work
1131 cm->follow_marking_stacks();
1132 }
1133
1134 {
1135 PCAddThreadRootsMarkingTaskClosure closure(cm);
1136 Threads::possibly_parallel_threads_do(_active_workers > 1 /* is_par */, &closure);
1137 }
1138
1139 // Mark from OopStorages
1140 {
1141 _oop_storage_set_par_state.oops_do(&cm->_mark_and_push_closure);
1142 // Do the real work
1143 cm->follow_marking_stacks();
1144 }
1145
1146 if (_active_workers > 1) {
1147 steal_marking_work(_terminator, worker_id);
1148 }
1149 }
1150 };
1151
1152 class ParallelCompactRefProcProxyTask : public RefProcProxyTask {
1153 TaskTerminator _terminator;
1154
1155 public:
1156 ParallelCompactRefProcProxyTask(uint max_workers)
1157 : RefProcProxyTask("ParallelCompactRefProcProxyTask", max_workers),
1158 _terminator(_max_workers, ParCompactionManager::marking_stacks()) {}
1159
1160 void work(uint worker_id) override {
1161 assert(worker_id < _max_workers, "sanity");
1162 ParCompactionManager* cm = (_tm == RefProcThreadModel::Single) ? ParCompactionManager::get_vmthread_cm() : ParCompactionManager::gc_thread_compaction_manager(worker_id);
1163 BarrierEnqueueDiscoveredFieldClosure enqueue;
1164 ParCompactionManager::FollowStackClosure complete_gc(cm, (_tm == RefProcThreadModel::Single) ? nullptr : &_terminator, worker_id);
1165 _rp_task->rp_work(worker_id, PSParallelCompact::is_alive_closure(), &cm->_mark_and_push_closure, &enqueue, &complete_gc);
1166 }
1167
1168 void prepare_run_task_hook() override {
1169 _terminator.reset_for_reuse(_queue_count);
1170 }
1171 };
1172
1173 static void flush_marking_stats_cache(const uint num_workers) {
1174 for (uint i = 0; i < num_workers; ++i) {
1175 ParCompactionManager* cm = ParCompactionManager::gc_thread_compaction_manager(i);
1176 cm->flush_and_destroy_marking_stats_cache();
1177 }
1178 }
1179
1180 class PSParallelCleaningTask : public WorkerTask {
1181 bool _unloading_occurred;
1182 CodeCacheUnloadingTask _code_cache_task;
1183 // Prune dead klasses from subklass/sibling/implementor lists.
1184 KlassCleaningTask _klass_cleaning_task;
1185
1186 public:
1187 PSParallelCleaningTask(bool unloading_occurred) :
1188 WorkerTask("PS Parallel Cleaning"),
1189 _unloading_occurred(unloading_occurred),
1190 _code_cache_task(unloading_occurred),
1191 _klass_cleaning_task() {}
1192
1193 void work(uint worker_id) {
1194 #if INCLUDE_JVMCI
1195 if (EnableJVMCI && worker_id == 0) {
1196 // Serial work; only first worker.
1197 // Clean JVMCI metadata handles.
1198 JVMCI::do_unloading(_unloading_occurred);
1199 }
1200 #endif
1201
1202 // Do first pass of code cache cleaning.
1203 _code_cache_task.work(worker_id);
1204
1205 // Clean all klasses that were not unloaded.
1206 // The weak metadata in klass doesn't need to be
1207 // processed if there was no unloading.
1208 if (_unloading_occurred) {
1209 _klass_cleaning_task.work();
1210 }
1211 }
1212 };
1213
1214 void PSParallelCompact::marking_phase(ParallelOldTracer *gc_tracer) {
1215 // Recursively traverse all live objects and mark them
1216 GCTraceTime(Info, gc, phases) tm("Marking Phase", &_gc_timer);
1217
1218 uint active_gc_threads = ParallelScavengeHeap::heap()->workers().active_workers();
1219
1220 ClassLoaderDataGraph::verify_claimed_marks_cleared(ClassLoaderData::_claim_stw_fullgc_mark);
1221 {
1222 GCTraceTime(Debug, gc, phases) tm("Par Mark", &_gc_timer);
1223
1224 MarkFromRootsTask task(active_gc_threads);
1225 ParallelScavengeHeap::heap()->workers().run_task(&task);
1226 }
1227
1228 // Process reference objects found during marking
1229 {
1230 GCTraceTime(Debug, gc, phases) tm("Reference Processing", &_gc_timer);
1231
1232 ReferenceProcessorStats stats;
1233 ReferenceProcessorPhaseTimes pt(&_gc_timer, ref_processor()->max_num_queues());
1234
1235 ParallelCompactRefProcProxyTask task(ref_processor()->max_num_queues());
1236 stats = ref_processor()->process_discovered_references(task, &ParallelScavengeHeap::heap()->workers(), pt);
1237
1238 gc_tracer->report_gc_reference_stats(stats);
1239 pt.print_all_references();
1240 }
1241
1242 {
1243 GCTraceTime(Debug, gc, phases) tm("Flush Marking Stats", &_gc_timer);
1244
1245 flush_marking_stats_cache(active_gc_threads);
1246 }
1247
1248 // This is the point where the entire marking should have completed.
1249 ParCompactionManager::verify_all_marking_stack_empty();
1250
1251 {
1252 GCTraceTime(Debug, gc, phases) tm("Weak Processing", &_gc_timer);
1253 WeakProcessor::weak_oops_do(&ParallelScavengeHeap::heap()->workers(),
1254 is_alive_closure(),
1255 &do_nothing_cl,
1256 1);
1257 }
1258
1259 {
1260 GCTraceTime(Debug, gc, phases) tm_m("Class Unloading", &_gc_timer);
1261
1262 ClassUnloadingContext ctx(active_gc_threads /* num_nmethod_unlink_workers */,
1263 false /* unregister_nmethods_during_purge */,
1264 false /* lock_nmethod_free_separately */);
1265
1266 {
1267 CodeCache::UnlinkingScope scope(is_alive_closure());
1268
1269 // Follow system dictionary roots and unload classes.
1270 bool unloading_occurred = SystemDictionary::do_unloading(&_gc_timer);
1271
1272 PSParallelCleaningTask task{unloading_occurred};
1273 ParallelScavengeHeap::heap()->workers().run_task(&task);
1274 }
1275
1276 {
1277 GCTraceTime(Debug, gc, phases) t("Purge Unlinked NMethods", gc_timer());
1278 // Release unloaded nmethod's memory.
1279 ctx.purge_nmethods();
1280 }
1281 {
1282 GCTraceTime(Debug, gc, phases) ur("Unregister NMethods", &_gc_timer);
1283 ParallelScavengeHeap::heap()->prune_unlinked_nmethods();
1284 }
1285 {
1286 GCTraceTime(Debug, gc, phases) t("Free Code Blobs", gc_timer());
1287 ctx.free_nmethods();
1288 }
1289 {
1290 // Delete metaspaces for unloaded class loaders and clean up loader_data graph
1291 GCTraceTime(Debug, gc, phases) t("Purge Class Loader Data", gc_timer());
1292 ClassLoaderDataGraph::purge(true /* at_safepoint */);
1293 DEBUG_ONLY(MetaspaceUtils::verify();)
1294 }
1295 }
1296
1297 #if TASKQUEUE_STATS
1298 ParCompactionManager::print_and_reset_taskqueue_stats();
1299 #endif
1300 }
1301
1302 template<typename Func>
1303 void PSParallelCompact::adjust_in_space_helper(SpaceId id, Atomic<uint>* claim_counter, Func&& on_stripe) {
1304 MutableSpace* sp = PSParallelCompact::space(id);
1305 HeapWord* const bottom = sp->bottom();
1306 HeapWord* const top = sp->top();
1307 if (bottom == top) {
1308 return;
1309 }
1310
1311 const uint num_regions_per_stripe = 2;
1312 const size_t region_size = ParallelCompactData::RegionSize;
1313 const size_t stripe_size = num_regions_per_stripe * region_size;
1314
1315 while (true) {
1316 uint counter = claim_counter->fetch_then_add(num_regions_per_stripe);
1317 HeapWord* cur_stripe = bottom + counter * region_size;
1318 if (cur_stripe >= top) {
1319 break;
1320 }
1321 HeapWord* stripe_end = MIN2(cur_stripe + stripe_size, top);
1322 on_stripe(cur_stripe, stripe_end);
1323 }
1324 }
1325
1326 void PSParallelCompact::adjust_in_old_space(Atomic<uint>* claim_counter) {
1327 // Regions in old-space shouldn't be split.
1328 assert(!_space_info[old_space_id].split_info().is_valid(), "inv");
1329
1330 auto scan_obj_with_limit = [&] (HeapWord* obj_start, HeapWord* left, HeapWord* right) {
1331 assert(mark_bitmap()->is_marked(obj_start), "inv");
1332 oop obj = cast_to_oop(obj_start);
1333 return obj->oop_iterate_size(&pc_adjust_pointer_closure, MemRegion(left, right));
1334 };
1335
1336 adjust_in_space_helper(old_space_id, claim_counter, [&] (HeapWord* stripe_start, HeapWord* stripe_end) {
1337 assert(_summary_data.is_region_aligned(stripe_start), "inv");
1338 RegionData* cur_region = _summary_data.addr_to_region_ptr(stripe_start);
1339 HeapWord* obj_start;
1340 if (cur_region->partial_obj_size() != 0) {
1341 obj_start = cur_region->partial_obj_addr();
1342 obj_start += scan_obj_with_limit(obj_start, stripe_start, stripe_end);
1343 } else {
1344 obj_start = stripe_start;
1345 }
1346
1347 while (obj_start < stripe_end) {
1348 obj_start = mark_bitmap()->find_obj_beg(obj_start, stripe_end);
1349 if (obj_start >= stripe_end) {
1350 break;
1351 }
1352 obj_start += scan_obj_with_limit(obj_start, stripe_start, stripe_end);
1353 }
1354 });
1355 }
1356
1357 void PSParallelCompact::adjust_in_young_space(SpaceId id, Atomic<uint>* claim_counter) {
1358 adjust_in_space_helper(id, claim_counter, [](HeapWord* stripe_start, HeapWord* stripe_end) {
1359 HeapWord* obj_start = stripe_start;
1360 while (obj_start < stripe_end) {
1361 obj_start = mark_bitmap()->find_obj_beg(obj_start, stripe_end);
1362 if (obj_start >= stripe_end) {
1363 break;
1364 }
1365 oop obj = cast_to_oop(obj_start);
1366 obj_start += obj->oop_iterate_size(&pc_adjust_pointer_closure);
1367 }
1368 });
1369 }
1370
1371 void PSParallelCompact::adjust_pointers_in_spaces(uint worker_id, Atomic<uint>* claim_counters) {
1372 auto start_time = Ticks::now();
1373 adjust_in_old_space(&claim_counters[0]);
1374 for (uint id = eden_space_id; id < last_space_id; ++id) {
1375 adjust_in_young_space(SpaceId(id), &claim_counters[id]);
1376 }
1377 log_trace(gc, phases)("adjust_pointers_in_spaces worker %u: %.3f ms", worker_id, (Ticks::now() - start_time).seconds() * 1000);
1378 }
1379
1380 class PSAdjustTask final : public WorkerTask {
1381 ThreadsClaimTokenScope _threads_claim_token_scope;
1382 WeakProcessor::Task _weak_proc_task;
1383 OopStorageSetStrongParState<false, false> _oop_storage_iter;
1384 uint _nworkers;
1385 Atomic<bool> _code_cache_claimed;
1386 Atomic<uint> _claim_counters[PSParallelCompact::last_space_id];
1387
1388 bool try_claim_code_cache_task() {
1389 return _code_cache_claimed.load_relaxed() == false
1390 && _code_cache_claimed.compare_set(false, true);
1391 }
1392
1393 public:
1394 PSAdjustTask(uint nworkers) :
1395 WorkerTask("PSAdjust task"),
1396 _threads_claim_token_scope(),
1397 _weak_proc_task(nworkers),
1398 _oop_storage_iter(),
1399 _nworkers(nworkers),
1400 _code_cache_claimed(false) {
1401
1402 for (unsigned int i = PSParallelCompact::old_space_id; i < PSParallelCompact::last_space_id; ++i) {
1403 ::new (&_claim_counters[i]) Atomic<uint>{};
1404 }
1405 ClassLoaderDataGraph::verify_claimed_marks_cleared(ClassLoaderData::_claim_stw_fullgc_adjust);
1406 }
1407
1408 void work(uint worker_id) {
1409 {
1410 // Pointers in heap.
1411 ParCompactionManager* cm = ParCompactionManager::gc_thread_compaction_manager(worker_id);
1412 cm->preserved_marks()->adjust_during_full_gc();
1413
1414 PSParallelCompact::adjust_pointers_in_spaces(worker_id, _claim_counters);
1415 }
1416
1417 {
1418 // All (strong and weak) CLDs.
1419 CLDToOopClosure cld_closure(&pc_adjust_pointer_closure, ClassLoaderData::_claim_stw_fullgc_adjust);
1420 ClassLoaderDataGraph::cld_do(&cld_closure);
1421 }
1422
1423 {
1424 // Threads stack frames. No need to visit on-stack nmethods, because all
1425 // nmethods are visited in one go via CodeCache::nmethods_do.
1426 ResourceMark rm;
1427 Threads::possibly_parallel_oops_do(_nworkers > 1, &pc_adjust_pointer_closure, nullptr);
1428 if (try_claim_code_cache_task()) {
1429 NMethodToOopClosure adjust_code(&pc_adjust_pointer_closure, NMethodToOopClosure::FixRelocations);
1430 CodeCache::nmethods_do(&adjust_code);
1431 }
1432 }
1433
1434 {
1435 // VM internal strong and weak roots.
1436 _oop_storage_iter.oops_do(&pc_adjust_pointer_closure);
1437 AlwaysTrueClosure always_alive;
1438 _weak_proc_task.work(worker_id, &always_alive, &pc_adjust_pointer_closure);
1439 }
1440 }
1441 };
1442
1443 void PSParallelCompact::adjust_pointers() {
1444 // Adjust the pointers to reflect the new locations
1445 GCTraceTime(Info, gc, phases) tm("Adjust Pointers", &_gc_timer);
1446 uint nworkers = ParallelScavengeHeap::heap()->workers().active_workers();
1447 PSAdjustTask task(nworkers);
1448 ParallelScavengeHeap::heap()->workers().run_task(&task);
1449 }
1450
1451 // Split [start, end) evenly for a number of workers and return the
1452 // range for worker_id.
1453 static void split_regions_for_worker(size_t start, size_t end,
1454 uint worker_id, uint num_workers,
1455 size_t* worker_start, size_t* worker_end) {
1456 assert(start < end, "precondition");
1457 assert(num_workers > 0, "precondition");
1458 assert(worker_id < num_workers, "precondition");
1459
1460 size_t num_regions = end - start;
1461 size_t num_regions_per_worker = num_regions / num_workers;
1462 size_t remainder = num_regions % num_workers;
1463 // The first few workers will get one extra.
1464 *worker_start = start + worker_id * num_regions_per_worker
1465 + MIN2(checked_cast<size_t>(worker_id), remainder);
1466 *worker_end = *worker_start + num_regions_per_worker
1467 + (worker_id < remainder ? 1 : 0);
1468 }
1469
1470 void PSParallelCompact::forward_to_new_addr() {
1471 GCTraceTime(Info, gc, phases) tm("Forward", &_gc_timer);
1472 uint nworkers = ParallelScavengeHeap::heap()->workers().active_workers();
1473
1474 struct ForwardTask final : public WorkerTask {
1475 uint _num_workers;
1476
1477 explicit ForwardTask(uint num_workers) :
1478 WorkerTask("PSForward task"),
1479 _num_workers(num_workers) {}
1480
1481 static void forward_objs_in_range(ParCompactionManager* cm,
1482 HeapWord* start,
1483 HeapWord* end,
1484 HeapWord* destination) {
1485 HeapWord* cur_addr = start;
1486 HeapWord* new_addr = destination;
1487
1488 while (cur_addr < end) {
1489 cur_addr = mark_bitmap()->find_obj_beg(cur_addr, end);
1490 if (cur_addr >= end) {
1491 return;
1492 }
1493 assert(mark_bitmap()->is_marked(cur_addr), "inv");
1494 oop obj = cast_to_oop(cur_addr);
1495 if (new_addr != cur_addr) {
1496 cm->preserved_marks()->push_if_necessary(obj, obj->mark());
1497 FullGCForwarding::forward_to(obj, cast_to_oop(new_addr));
1498 }
1499 size_t obj_size = obj->size();
1500 new_addr += obj_size;
1501 cur_addr += obj_size;
1502 }
1503 }
1504
1505 void work(uint worker_id) override {
1506 ParCompactionManager* cm = ParCompactionManager::gc_thread_compaction_manager(worker_id);
1507 for (uint id = old_space_id; id < last_space_id; ++id) {
1508 MutableSpace* sp = PSParallelCompact::space(SpaceId(id));
1509 HeapWord* dense_prefix_addr = dense_prefix(SpaceId(id));
1510 HeapWord* top = sp->top();
1511
1512 if (dense_prefix_addr == top) {
1513 // Empty space
1514 continue;
1515 }
1516
1517 const SplitInfo& split_info = _space_info[SpaceId(id)].split_info();
1518 size_t dense_prefix_region = _summary_data.addr_to_region_idx(dense_prefix_addr);
1519 size_t top_region = _summary_data.addr_to_region_idx(_summary_data.region_align_up(top));
1520 size_t start_region;
1521 size_t end_region;
1522 split_regions_for_worker(dense_prefix_region, top_region,
1523 worker_id, _num_workers,
1524 &start_region, &end_region);
1525 for (size_t cur_region = start_region; cur_region < end_region; ++cur_region) {
1526 RegionData* region_ptr = _summary_data.region(cur_region);
1527 size_t partial_obj_size = region_ptr->partial_obj_size();
1528
1529 if (partial_obj_size == ParallelCompactData::RegionSize) {
1530 // No obj-start
1531 continue;
1532 }
1533
1534 HeapWord* region_start = _summary_data.region_to_addr(cur_region);
1535 HeapWord* region_end = region_start + ParallelCompactData::RegionSize;
1536
1537 if (split_info.is_split(cur_region)) {
1538 // Part 1: will be relocated to space-1
1539 HeapWord* preceding_destination = split_info.preceding_destination();
1540 HeapWord* split_point = split_info.split_point();
1541 forward_objs_in_range(cm, region_start + partial_obj_size, split_point, preceding_destination + partial_obj_size);
1542
1543 // Part 2: will be relocated to space-2
1544 HeapWord* destination = region_ptr->destination();
1545 forward_objs_in_range(cm, split_point, region_end, destination);
1546 } else {
1547 HeapWord* destination = region_ptr->destination();
1548 forward_objs_in_range(cm, region_start + partial_obj_size, region_end, destination + partial_obj_size);
1549 }
1550 }
1551 }
1552 }
1553 } task(nworkers);
1554
1555 ParallelScavengeHeap::heap()->workers().run_task(&task);
1556 DEBUG_ONLY(verify_forward();)
1557 }
1558
1559 #ifdef ASSERT
1560 void PSParallelCompact::verify_forward() {
1561 HeapWord* const old_dense_prefix_addr = dense_prefix(SpaceId(old_space_id));
1562 // The destination addr for the first live obj after dense-prefix.
1563 HeapWord* bump_ptr = old_dense_prefix_addr
1564 + _summary_data.addr_to_region_ptr(old_dense_prefix_addr)->partial_obj_size();
1565 SpaceId bump_ptr_space = old_space_id;
1566
1567 for (uint id = old_space_id; id < last_space_id; ++id) {
1568 MutableSpace* sp = PSParallelCompact::space(SpaceId(id));
1569 // Only verify objs after dense-prefix, because those before dense-prefix are not moved (forwarded).
1570 HeapWord* cur_addr = dense_prefix(SpaceId(id));
1571 HeapWord* top = sp->top();
1572
1573 while (cur_addr < top) {
1574 cur_addr = mark_bitmap()->find_obj_beg(cur_addr, top);
1575 if (cur_addr >= top) {
1576 break;
1577 }
1578 assert(mark_bitmap()->is_marked(cur_addr), "inv");
1579 assert(bump_ptr <= _space_info[bump_ptr_space].new_top(), "inv");
1580 // Move to the space containing cur_addr
1581 if (bump_ptr == _space_info[bump_ptr_space].new_top()) {
1582 bump_ptr = space(space_id(cur_addr))->bottom();
1583 bump_ptr_space = space_id(bump_ptr);
1584 }
1585 oop obj = cast_to_oop(cur_addr);
1586 if (cur_addr == bump_ptr) {
1587 assert(!FullGCForwarding::is_forwarded(obj), "inv");
1588 } else {
1589 assert(FullGCForwarding::forwardee(obj) == cast_to_oop(bump_ptr), "inv");
1590 }
1591 bump_ptr += obj->size();
1592 cur_addr += obj->size();
1593 }
1594 }
1595 }
1596 #endif
1597
1598 // Helper class to print 8 region numbers per line and then print the total at the end.
1599 class FillableRegionLogger : public StackObj {
1600 private:
1601 Log(gc, compaction) log;
1602 static const int LineLength = 8;
1603 size_t _regions[LineLength];
1604 int _next_index;
1605 bool _enabled;
1606 size_t _total_regions;
1607 public:
1608 FillableRegionLogger() : _next_index(0), _enabled(log_develop_is_enabled(Trace, gc, compaction)), _total_regions(0) { }
1609 ~FillableRegionLogger() {
1610 log.trace("%zu initially fillable regions", _total_regions);
1611 }
1612
1613 void print_line() {
1614 if (!_enabled || _next_index == 0) {
1615 return;
1616 }
1617 FormatBuffer<> line("Fillable: ");
1618 for (int i = 0; i < _next_index; i++) {
1619 line.append(" %7zu", _regions[i]);
1620 }
1621 log.trace("%s", line.buffer());
1622 _next_index = 0;
1623 }
1624
1625 void handle(size_t region) {
1626 if (!_enabled) {
1627 return;
1628 }
1629 _regions[_next_index++] = region;
1630 if (_next_index == LineLength) {
1631 print_line();
1632 }
1633 _total_regions++;
1634 }
1635 };
1636
1637 void PSParallelCompact::prepare_region_draining_tasks(uint parallel_gc_threads)
1638 {
1639 GCTraceTime(Trace, gc, phases) tm("Drain Task Setup", &_gc_timer);
1640
1641 // Find the threads that are active
1642 uint worker_id = 0;
1643
1644 // Find all regions that are available (can be filled immediately) and
1645 // distribute them to the thread stacks. The iteration is done in reverse
1646 // order (high to low) so the regions will be removed in ascending order.
1647
1648 const ParallelCompactData& sd = PSParallelCompact::summary_data();
1649
1650 // id + 1 is used to test termination so unsigned can
1651 // be used with an old_space_id == 0.
1652 FillableRegionLogger region_logger;
1653 for (unsigned int id = last_space_id - 1; id + 1 > old_space_id; --id) {
1654 SpaceInfo* const space_info = _space_info + id;
1655 HeapWord* const new_top = space_info->new_top();
1656
1657 const size_t beg_region = sd.addr_to_region_idx(space_info->dense_prefix());
1658 const size_t end_region =
1659 sd.addr_to_region_idx(sd.region_align_up(new_top));
1660
1661 for (size_t cur = end_region - 1; cur + 1 > beg_region; --cur) {
1662 if (sd.region(cur)->claim_unsafe()) {
1663 ParCompactionManager* cm = ParCompactionManager::gc_thread_compaction_manager(worker_id);
1664 bool result = sd.region(cur)->mark_normal();
1665 assert(result, "Must succeed at this point.");
1666 cm->region_stack()->push(cur);
1667 region_logger.handle(cur);
1668 // Assign regions to tasks in round-robin fashion.
1669 if (++worker_id == parallel_gc_threads) {
1670 worker_id = 0;
1671 }
1672 }
1673 }
1674 region_logger.print_line();
1675 }
1676 }
1677
1678 static void compaction_with_stealing_work(TaskTerminator* terminator, uint worker_id) {
1679 assert(ParallelScavengeHeap::heap()->is_stw_gc_active(), "called outside gc");
1680
1681 ParCompactionManager* cm =
1682 ParCompactionManager::gc_thread_compaction_manager(worker_id);
1683
1684 // Drain the stacks that have been preloaded with regions
1685 // that are ready to fill.
1686
1687 cm->drain_region_stacks();
1688
1689 guarantee(cm->region_stack()->is_empty(), "Not empty");
1690
1691 size_t region_index = 0;
1692
1693 while (true) {
1694 if (ParCompactionManager::steal(worker_id, region_index)) {
1695 PSParallelCompact::fill_and_update_region(cm, region_index);
1696 cm->drain_region_stacks();
1697 } else if (PSParallelCompact::steal_unavailable_region(cm, region_index)) {
1698 // Fill and update an unavailable region with the help of a shadow region
1699 PSParallelCompact::fill_and_update_shadow_region(cm, region_index);
1700 cm->drain_region_stacks();
1701 } else {
1702 if (terminator->offer_termination()) {
1703 break;
1704 }
1705 // Go around again.
1706 }
1707 }
1708 }
1709
1710 class FillDensePrefixAndCompactionTask: public WorkerTask {
1711 TaskTerminator _terminator;
1712
1713 public:
1714 FillDensePrefixAndCompactionTask(uint active_workers) :
1715 WorkerTask("FillDensePrefixAndCompactionTask"),
1716 _terminator(active_workers, ParCompactionManager::region_task_queues()) {
1717 }
1718
1719 virtual void work(uint worker_id) {
1720 if (worker_id == 0) {
1721 auto start = Ticks::now();
1722 PSParallelCompact::fill_dead_objs_in_dense_prefix();
1723 log_trace(gc, phases)("Fill dense prefix by worker 0: %.3f ms", (Ticks::now() - start).seconds() * 1000);
1724 }
1725 compaction_with_stealing_work(&_terminator, worker_id);
1726 }
1727 };
1728
1729 void PSParallelCompact::fill_range_in_dense_prefix(HeapWord* start, HeapWord* end) {
1730 #ifdef ASSERT
1731 {
1732 assert(start < end, "precondition");
1733 assert(mark_bitmap()->find_obj_beg(start, end) == end, "precondition");
1734 HeapWord* bottom = _space_info[old_space_id].space()->bottom();
1735 if (start != bottom) {
1736 // The preceding live obj.
1737 HeapWord* obj_start = mark_bitmap()->find_obj_beg_reverse(bottom, start);
1738 HeapWord* obj_end = obj_start + cast_to_oop(obj_start)->size();
1739 assert(obj_end == start, "precondition");
1740 }
1741 }
1742 #endif
1743
1744 CollectedHeap::fill_with_objects(start, pointer_delta(end, start));
1745 HeapWord* addr = start;
1746 do {
1747 size_t size = cast_to_oop(addr)->size();
1748 start_array(old_space_id)->update_for_block(addr, addr + size);
1749 addr += size;
1750 } while (addr < end);
1751 }
1752
1753 void PSParallelCompact::fill_dead_objs_in_dense_prefix() {
1754 ParMarkBitMap* bitmap = mark_bitmap();
1755
1756 HeapWord* const bottom = _space_info[old_space_id].space()->bottom();
1757 HeapWord* const prefix_end = dense_prefix(old_space_id);
1758
1759 const size_t region_size = ParallelCompactData::RegionSize;
1760
1761 // Fill dead space in [start_addr, end_addr)
1762 HeapWord* const start_addr = bottom;
1763 HeapWord* const end_addr = prefix_end;
1764
1765 for (HeapWord* cur_addr = start_addr; cur_addr < end_addr; /* empty */) {
1766 RegionData* cur_region_ptr = _summary_data.addr_to_region_ptr(cur_addr);
1767 if (cur_region_ptr->data_size() == region_size) {
1768 // Full; no dead space. Next region.
1769 if (_summary_data.is_region_aligned(cur_addr)) {
1770 cur_addr += region_size;
1771 } else {
1772 cur_addr = _summary_data.region_align_up(cur_addr);
1773 }
1774 continue;
1775 }
1776
1777 // Fill dead space inside cur_region.
1778 if (_summary_data.is_region_aligned(cur_addr)) {
1779 cur_addr += cur_region_ptr->partial_obj_size();
1780 }
1781
1782 HeapWord* region_end_addr = _summary_data.region_align_up(cur_addr + 1);
1783 assert(region_end_addr <= end_addr, "inv");
1784 while (cur_addr < region_end_addr) {
1785 // Use end_addr to allow filler-obj to cross region boundary.
1786 HeapWord* live_start = bitmap->find_obj_beg(cur_addr, end_addr);
1787 if (cur_addr != live_start) {
1788 // Found dead space [cur_addr, live_start).
1789 fill_range_in_dense_prefix(cur_addr, live_start);
1790 }
1791 if (live_start >= region_end_addr) {
1792 cur_addr = live_start;
1793 break;
1794 }
1795 assert(bitmap->is_marked(live_start), "inv");
1796 cur_addr = live_start + cast_to_oop(live_start)->size();
1797 }
1798 }
1799 }
1800
1801 void PSParallelCompact::compact() {
1802 GCTraceTime(Info, gc, phases) tm("Compaction Phase", &_gc_timer);
1803
1804 uint active_gc_threads = ParallelScavengeHeap::heap()->workers().active_workers();
1805
1806 initialize_shadow_regions(active_gc_threads);
1807 prepare_region_draining_tasks(active_gc_threads);
1808
1809 {
1810 GCTraceTime(Trace, gc, phases) tm("Par Compact", &_gc_timer);
1811
1812 FillDensePrefixAndCompactionTask task(active_gc_threads);
1813 ParallelScavengeHeap::heap()->workers().run_task(&task);
1814
1815 #ifdef ASSERT
1816 verify_filler_in_dense_prefix();
1817
1818 // Verify that all regions have been processed.
1819 for (unsigned int id = old_space_id; id < last_space_id; ++id) {
1820 verify_complete(SpaceId(id));
1821 }
1822 #endif
1823 }
1824 }
1825
1826 #ifdef ASSERT
1827 void PSParallelCompact::verify_filler_in_dense_prefix() {
1828 HeapWord* bottom = _space_info[old_space_id].space()->bottom();
1829 HeapWord* dense_prefix_end = dense_prefix(old_space_id);
1830
1831 const size_t region_size = ParallelCompactData::RegionSize;
1832
1833 for (HeapWord* cur_addr = bottom; cur_addr < dense_prefix_end; /* empty */) {
1834 RegionData* cur_region_ptr = _summary_data.addr_to_region_ptr(cur_addr);
1835 if (cur_region_ptr->data_size() == region_size) {
1836 // Full; no dead space. Next region.
1837 if (_summary_data.is_region_aligned(cur_addr)) {
1838 cur_addr += region_size;
1839 } else {
1840 cur_addr = _summary_data.region_align_up(cur_addr);
1841 }
1842 continue;
1843 }
1844
1845 // This region contains filler objs.
1846 if (_summary_data.is_region_aligned(cur_addr)) {
1847 cur_addr += cur_region_ptr->partial_obj_size();
1848 }
1849
1850 HeapWord* region_end_addr = _summary_data.region_align_up(cur_addr + 1);
1851 assert(region_end_addr <= dense_prefix_end, "inv");
1852
1853 while (cur_addr < region_end_addr) {
1854 oop obj = cast_to_oop(cur_addr);
1855 oopDesc::verify(obj);
1856 if (!mark_bitmap()->is_marked(cur_addr)) {
1857 assert(CollectedHeap::is_filler_object(cast_to_oop(cur_addr)), "inv");
1858 }
1859 cur_addr += obj->size();
1860 }
1861 }
1862 }
1863
1864 void PSParallelCompact::verify_complete(SpaceId space_id) {
1865 // All Regions served as compaction targets, from dense_prefix() to
1866 // new_top(), should be marked as filled and all Regions between new_top()
1867 // and top() should be available (i.e., should have been emptied).
1868 ParallelCompactData& sd = summary_data();
1869 SpaceInfo si = _space_info[space_id];
1870 HeapWord* new_top_addr = sd.region_align_up(si.new_top());
1871 HeapWord* old_top_addr = sd.region_align_up(si.space()->top());
1872 const size_t beg_region = sd.addr_to_region_idx(si.dense_prefix());
1873 const size_t new_top_region = sd.addr_to_region_idx(new_top_addr);
1874 const size_t old_top_region = sd.addr_to_region_idx(old_top_addr);
1875
1876 size_t cur_region;
1877 for (cur_region = beg_region; cur_region < new_top_region; ++cur_region) {
1878 const RegionData* const c = sd.region(cur_region);
1879 assert(c->completed(), "region %zu not filled: destination_count=%u",
1880 cur_region, c->destination_count());
1881 }
1882
1883 for (cur_region = new_top_region; cur_region < old_top_region; ++cur_region) {
1884 const RegionData* const c = sd.region(cur_region);
1885 assert(c->available(), "region %zu not empty: destination_count=%u",
1886 cur_region, c->destination_count());
1887 }
1888 }
1889 #endif // #ifdef ASSERT
1890
1891 // Return the SpaceId for the space containing addr. If addr is not in the
1892 // heap, last_space_id is returned. In debug mode it expects the address to be
1893 // in the heap and asserts such.
1894 PSParallelCompact::SpaceId PSParallelCompact::space_id(HeapWord* addr) {
1895 assert(ParallelScavengeHeap::heap()->is_in_reserved(addr), "addr not in the heap");
1896
1897 for (unsigned int id = old_space_id; id < last_space_id; ++id) {
1898 if (_space_info[id].space()->contains(addr)) {
1899 return SpaceId(id);
1900 }
1901 }
1902
1903 assert(false, "no space contains the addr");
1904 return last_space_id;
1905 }
1906
1907 // Skip over count live words starting from beg, and return the address of the
1908 // next live word. Callers must also ensure that there are enough live words in
1909 // the range [beg, end) to skip.
1910 HeapWord* PSParallelCompact::skip_live_words(HeapWord* beg, HeapWord* end, size_t count)
1911 {
1912 ParMarkBitMap* m = mark_bitmap();
1913 HeapWord* cur_addr = beg;
1914 while (true) {
1915 cur_addr = m->find_obj_beg(cur_addr, end);
1916 assert(cur_addr < end, "inv");
1917 size_t obj_size = cast_to_oop(cur_addr)->size();
1918 // Strictly greater-than
1919 if (obj_size > count) {
1920 return cur_addr + count;
1921 }
1922 count -= obj_size;
1923 cur_addr += obj_size;
1924 }
1925 }
1926
1927 // On starting to fill a destination region (dest-region), we need to know the
1928 // location of the word that will be at the start of the dest-region after
1929 // compaction. A dest-region can have one or more source regions, but only the
1930 // first source-region contains this location. This location is retrieved by
1931 // calling `first_src_addr` on a dest-region.
1932 // Conversely, a source-region has a dest-region which holds the destination of
1933 // the first live word on this source-region, based on which the destination
1934 // for the rest of live words can be derived.
1935 //
1936 // Note:
1937 // There is some complication due to space-boundary-fragmentation (an obj can't
1938 // cross space-boundary) -- a source-region may be split and behave like two
1939 // distinct regions with their own dest-region, as depicted below.
1940 //
1941 // source-region: region-n
1942 //
1943 // **********************
1944 // | A|A~~~~B|B |
1945 // **********************
1946 // n-1 n n+1
1947 //
1948 // AA, BB denote two live objs. ~~~~ denotes unknown number of live objs.
1949 //
1950 // Assuming the dest-region for region-n is the final region before
1951 // old-space-end and its first-live-word is the middle of AA, the heap content
1952 // will look like the following after compaction:
1953 //
1954 // ************** *************
1955 // A|A~~~~ | |BB |
1956 // ************** *************
1957 // ^ ^
1958 // | old-space-end | eden-space-start
1959 //
1960 // Therefore, in this example, region-n will have two dest-regions:
1961 // 1. the final region in old-space
1962 // 2. the first region in eden-space.
1963 // To handle this special case, we introduce the concept of split-region, whose
1964 // contents are relocated to two spaces. `SplitInfo` captures all necessary
1965 // info about the split, the first part, spliting-point, and the second part.
1966 HeapWord* PSParallelCompact::first_src_addr(HeapWord* const dest_addr,
1967 SpaceId src_space_id,
1968 size_t src_region_idx)
1969 {
1970 const size_t RegionSize = ParallelCompactData::RegionSize;
1971 const ParallelCompactData& sd = summary_data();
1972 assert(sd.is_region_aligned(dest_addr), "precondition");
1973
1974 const RegionData* const src_region_ptr = sd.region(src_region_idx);
1975 assert(src_region_ptr->data_size() > 0, "src region cannot be empty");
1976
1977 const size_t partial_obj_size = src_region_ptr->partial_obj_size();
1978 HeapWord* const src_region_destination = src_region_ptr->destination();
1979
1980 HeapWord* const region_start = sd.region_to_addr(src_region_idx);
1981 HeapWord* const region_end = sd.region_to_addr(src_region_idx) + RegionSize;
1982
1983 // Identify the actual destination for the first live words on this region,
1984 // taking split-region into account.
1985 HeapWord* region_start_destination;
1986 const SplitInfo& split_info = _space_info[src_space_id].split_info();
1987 if (split_info.is_split(src_region_idx)) {
1988 // The second part of this split region; use the recorded split point.
1989 if (dest_addr == src_region_destination) {
1990 return split_info.split_point();
1991 }
1992 region_start_destination = split_info.preceding_destination();
1993 } else {
1994 region_start_destination = src_region_destination;
1995 }
1996
1997 // Calculate the offset to be skipped
1998 size_t words_to_skip = pointer_delta(dest_addr, region_start_destination);
1999
2000 HeapWord* result;
2001 if (partial_obj_size > words_to_skip) {
2002 result = region_start + words_to_skip;
2003 } else {
2004 words_to_skip -= partial_obj_size;
2005 result = skip_live_words(region_start + partial_obj_size, region_end, words_to_skip);
2006 }
2007
2008 if (split_info.is_split(src_region_idx)) {
2009 assert(result < split_info.split_point(), "postcondition");
2010 } else {
2011 assert(result < region_end, "postcondition");
2012 }
2013
2014 return result;
2015 }
2016
2017 void PSParallelCompact::decrement_destination_counts(ParCompactionManager* cm,
2018 SpaceId src_space_id,
2019 size_t beg_region,
2020 HeapWord* end_addr)
2021 {
2022 ParallelCompactData& sd = summary_data();
2023
2024 #ifdef ASSERT
2025 MutableSpace* const src_space = _space_info[src_space_id].space();
2026 HeapWord* const beg_addr = sd.region_to_addr(beg_region);
2027 assert(src_space->contains(beg_addr) || beg_addr == src_space->end(),
2028 "src_space_id does not match beg_addr");
2029 assert(src_space->contains(end_addr) || end_addr == src_space->end(),
2030 "src_space_id does not match end_addr");
2031 #endif // #ifdef ASSERT
2032
2033 RegionData* const beg = sd.region(beg_region);
2034 RegionData* const end = sd.addr_to_region_ptr(sd.region_align_up(end_addr));
2035
2036 // Regions up to new_top() are enqueued if they become available.
2037 HeapWord* const new_top = _space_info[src_space_id].new_top();
2038 RegionData* const enqueue_end =
2039 sd.addr_to_region_ptr(sd.region_align_up(new_top));
2040
2041 for (RegionData* cur = beg; cur < end; ++cur) {
2042 assert(cur->data_size() > 0, "region must have live data");
2043 cur->decrement_destination_count();
2044 if (cur < enqueue_end && cur->available() && cur->claim()) {
2045 if (cur->mark_normal()) {
2046 cm->push_region(sd.region(cur));
2047 } else if (cur->mark_copied()) {
2048 // Try to copy the content of the shadow region back to its corresponding
2049 // heap region if the shadow region is filled. Otherwise, the GC thread
2050 // fills the shadow region will copy the data back (see
2051 // MoveAndUpdateShadowClosure::complete_region).
2052 copy_back(sd.region_to_addr(cur->shadow_region()), sd.region_to_addr(cur));
2053 ParCompactionManager::push_shadow_region_mt_safe(cur->shadow_region());
2054 cur->set_completed();
2055 }
2056 }
2057 }
2058 }
2059
2060 size_t PSParallelCompact::next_src_region(MoveAndUpdateClosure& closure,
2061 SpaceId& src_space_id,
2062 HeapWord*& src_space_top,
2063 HeapWord* end_addr)
2064 {
2065 ParallelCompactData& sd = PSParallelCompact::summary_data();
2066
2067 size_t src_region_idx = 0;
2068
2069 // Skip empty regions (if any) up to the top of the space.
2070 HeapWord* const src_aligned_up = sd.region_align_up(end_addr);
2071 RegionData* src_region_ptr = sd.addr_to_region_ptr(src_aligned_up);
2072 HeapWord* const top_aligned_up = sd.region_align_up(src_space_top);
2073 const RegionData* const top_region_ptr = sd.addr_to_region_ptr(top_aligned_up);
2074
2075 while (src_region_ptr < top_region_ptr && src_region_ptr->data_size() == 0) {
2076 ++src_region_ptr;
2077 }
2078
2079 if (src_region_ptr < top_region_ptr) {
2080 // Found the first non-empty region in the same space.
2081 src_region_idx = sd.region(src_region_ptr);
2082 closure.set_source(sd.region_to_addr(src_region_idx));
2083 return src_region_idx;
2084 }
2085
2086 // Switch to a new source space and find the first non-empty region.
2087 uint space_id = src_space_id + 1;
2088 assert(space_id < last_space_id, "not enough spaces");
2089
2090 for (/* empty */; space_id < last_space_id; ++space_id) {
2091 HeapWord* bottom = _space_info[space_id].space()->bottom();
2092 HeapWord* top = _space_info[space_id].space()->top();
2093 // Skip empty space
2094 if (bottom == top) {
2095 continue;
2096 }
2097
2098 // Identify the first region that contains live words in this space
2099 size_t cur_region = sd.addr_to_region_idx(bottom);
2100 size_t end_region = sd.addr_to_region_idx(sd.region_align_up(top));
2101
2102 for (/* empty */ ; cur_region < end_region; ++cur_region) {
2103 RegionData* cur = sd.region(cur_region);
2104 if (cur->live_obj_size() > 0) {
2105 HeapWord* region_start_addr = sd.region_to_addr(cur_region);
2106
2107 src_space_id = SpaceId(space_id);
2108 src_space_top = top;
2109 closure.set_source(region_start_addr);
2110 return cur_region;
2111 }
2112 }
2113 }
2114
2115 ShouldNotReachHere();
2116 }
2117
2118 HeapWord* PSParallelCompact::partial_obj_end(HeapWord* region_start_addr) {
2119 ParallelCompactData& sd = summary_data();
2120 assert(sd.is_region_aligned(region_start_addr), "precondition");
2121
2122 // Use per-region partial_obj_size to locate the end of the obj, that extends
2123 // to region_start_addr.
2124 size_t start_region_idx = sd.addr_to_region_idx(region_start_addr);
2125 size_t end_region_idx = sd.region_count();
2126 size_t accumulated_size = 0;
2127 for (size_t region_idx = start_region_idx; region_idx < end_region_idx; ++region_idx) {
2128 size_t cur_partial_obj_size = sd.region(region_idx)->partial_obj_size();
2129 accumulated_size += cur_partial_obj_size;
2130 if (cur_partial_obj_size != ParallelCompactData::RegionSize) {
2131 break;
2132 }
2133 }
2134 return region_start_addr + accumulated_size;
2135 }
2136
2137 // Use region_idx as the destination region, and evacuate all live objs on its
2138 // source regions to this destination region.
2139 void PSParallelCompact::fill_region(ParCompactionManager* cm, MoveAndUpdateClosure& closure, size_t region_idx)
2140 {
2141 ParMarkBitMap* const bitmap = mark_bitmap();
2142 ParallelCompactData& sd = summary_data();
2143 RegionData* const region_ptr = sd.region(region_idx);
2144
2145 // Get the source region and related info.
2146 size_t src_region_idx = region_ptr->source_region();
2147 SpaceId src_space_id = space_id(sd.region_to_addr(src_region_idx));
2148 HeapWord* src_space_top = _space_info[src_space_id].space()->top();
2149 HeapWord* dest_addr = sd.region_to_addr(region_idx);
2150
2151 closure.set_source(first_src_addr(dest_addr, src_space_id, src_region_idx));
2152
2153 // Adjust src_region_idx to prepare for decrementing destination counts (the
2154 // destination count is not decremented when a region is copied to itself).
2155 if (src_region_idx == region_idx) {
2156 src_region_idx += 1;
2157 }
2158
2159 // source-region:
2160 //
2161 // **********
2162 // | ~~~ |
2163 // **********
2164 // ^
2165 // |-- closure.source() / first_src_addr
2166 //
2167 //
2168 // ~~~ : live words
2169 //
2170 // destination-region:
2171 //
2172 // **********
2173 // | |
2174 // **********
2175 // ^
2176 // |-- region-start
2177 if (bitmap->is_unmarked(closure.source())) {
2178 // An object overflows the previous destination region, so this
2179 // destination region should copy the remainder of the object or as much as
2180 // will fit.
2181 HeapWord* const old_src_addr = closure.source();
2182 {
2183 HeapWord* region_start = sd.region_align_down(closure.source());
2184 HeapWord* obj_start = bitmap->find_obj_beg_reverse(region_start, closure.source());
2185 HeapWord* obj_end;
2186 if (obj_start != closure.source()) {
2187 assert(bitmap->is_marked(obj_start), "inv");
2188 // Found the actual obj-start, try to find the obj-end using either
2189 // size() if this obj is completely contained in the current region.
2190 HeapWord* next_region_start = region_start + ParallelCompactData::RegionSize;
2191 HeapWord* partial_obj_start = (next_region_start >= src_space_top)
2192 ? nullptr
2193 : sd.addr_to_region_ptr(next_region_start)->partial_obj_addr();
2194 // This obj extends to next region iff partial_obj_addr of the *next*
2195 // region is the same as obj-start.
2196 if (partial_obj_start == obj_start) {
2197 // This obj extends to next region.
2198 obj_end = partial_obj_end(next_region_start);
2199 } else {
2200 // Completely contained in this region; safe to use size().
2201 obj_end = obj_start + cast_to_oop(obj_start)->size();
2202 }
2203 } else {
2204 // This obj extends to current region.
2205 obj_end = partial_obj_end(region_start);
2206 }
2207 size_t partial_obj_size = pointer_delta(obj_end, closure.source());
2208 closure.copy_partial_obj(partial_obj_size);
2209 }
2210
2211 if (closure.is_full()) {
2212 decrement_destination_counts(cm, src_space_id, src_region_idx, closure.source());
2213 closure.complete_region(dest_addr, region_ptr);
2214 return;
2215 }
2216
2217 // Finished copying without using up the current destination-region
2218 HeapWord* const end_addr = sd.region_align_down(closure.source());
2219 if (sd.region_align_down(old_src_addr) != end_addr) {
2220 assert(sd.region_align_up(old_src_addr) == end_addr, "only one region");
2221 // The partial object was copied from more than one source region.
2222 decrement_destination_counts(cm, src_space_id, src_region_idx, end_addr);
2223
2224 // Move to the next source region, possibly switching spaces as well. All
2225 // args except end_addr may be modified.
2226 src_region_idx = next_src_region(closure, src_space_id, src_space_top, end_addr);
2227 }
2228 }
2229
2230 // Handle the rest obj-by-obj, where we know obj-start.
2231 do {
2232 HeapWord* cur_addr = closure.source();
2233 HeapWord* const end_addr = MIN2(sd.region_align_up(cur_addr + 1),
2234 src_space_top);
2235 // To handle the case where the final obj in source region extends to next region.
2236 HeapWord* final_obj_start = (end_addr == src_space_top)
2237 ? nullptr
2238 : sd.addr_to_region_ptr(end_addr)->partial_obj_addr();
2239 // Apply closure on objs inside [cur_addr, end_addr)
2240 do {
2241 cur_addr = bitmap->find_obj_beg(cur_addr, end_addr);
2242 if (cur_addr == end_addr) {
2243 break;
2244 }
2245 size_t obj_size;
2246 if (final_obj_start == cur_addr) {
2247 obj_size = pointer_delta(partial_obj_end(end_addr), cur_addr);
2248 } else {
2249 // This obj doesn't extend into next region; size() is safe to use.
2250 obj_size = cast_to_oop(cur_addr)->size();
2251 }
2252 closure.do_addr(cur_addr, obj_size);
2253 cur_addr += obj_size;
2254 } while (cur_addr < end_addr && !closure.is_full());
2255
2256 if (closure.is_full()) {
2257 decrement_destination_counts(cm, src_space_id, src_region_idx, closure.source());
2258 closure.complete_region(dest_addr, region_ptr);
2259 return;
2260 }
2261
2262 decrement_destination_counts(cm, src_space_id, src_region_idx, end_addr);
2263
2264 // Move to the next source region, possibly switching spaces as well. All
2265 // args except end_addr may be modified.
2266 src_region_idx = next_src_region(closure, src_space_id, src_space_top, end_addr);
2267 } while (true);
2268 }
2269
2270 void PSParallelCompact::fill_and_update_region(ParCompactionManager* cm, size_t region_idx)
2271 {
2272 MoveAndUpdateClosure cl(mark_bitmap(), region_idx);
2273 fill_region(cm, cl, region_idx);
2274 }
2275
2276 void PSParallelCompact::fill_and_update_shadow_region(ParCompactionManager* cm, size_t region_idx)
2277 {
2278 // Get a shadow region first
2279 ParallelCompactData& sd = summary_data();
2280 RegionData* const region_ptr = sd.region(region_idx);
2281 size_t shadow_region = ParCompactionManager::pop_shadow_region_mt_safe(region_ptr);
2282 // The InvalidShadow return value indicates the corresponding heap region is available,
2283 // so use MoveAndUpdateClosure to fill the normal region. Otherwise, use
2284 // MoveAndUpdateShadowClosure to fill the acquired shadow region.
2285 if (shadow_region == ParCompactionManager::InvalidShadow) {
2286 MoveAndUpdateClosure cl(mark_bitmap(), region_idx);
2287 region_ptr->shadow_to_normal();
2288 return fill_region(cm, cl, region_idx);
2289 } else {
2290 MoveAndUpdateShadowClosure cl(mark_bitmap(), region_idx, shadow_region);
2291 return fill_region(cm, cl, region_idx);
2292 }
2293 }
2294
2295 void PSParallelCompact::copy_back(HeapWord *shadow_addr, HeapWord *region_addr)
2296 {
2297 Copy::aligned_conjoint_words(shadow_addr, region_addr, _summary_data.RegionSize);
2298 }
2299
2300 bool PSParallelCompact::steal_unavailable_region(ParCompactionManager* cm, size_t ®ion_idx)
2301 {
2302 size_t next = cm->next_shadow_region();
2303 ParallelCompactData& sd = summary_data();
2304 size_t old_new_top = sd.addr_to_region_idx(_space_info[old_space_id].new_top());
2305 uint active_gc_threads = ParallelScavengeHeap::heap()->workers().active_workers();
2306
2307 while (next < old_new_top) {
2308 if (sd.region(next)->mark_shadow()) {
2309 region_idx = next;
2310 return true;
2311 }
2312 next = cm->move_next_shadow_region_by(active_gc_threads);
2313 }
2314
2315 return false;
2316 }
2317
2318 // The shadow region is an optimization to address region dependencies in full GC. The basic
2319 // idea is making more regions available by temporally storing their live objects in empty
2320 // shadow regions to resolve dependencies between them and the destination regions. Therefore,
2321 // GC threads need not wait destination regions to be available before processing sources.
2322 //
2323 // A typical workflow would be:
2324 // After draining its own stack and failing to steal from others, a GC worker would pick an
2325 // unavailable region (destination count > 0) and get a shadow region. Then the worker fills
2326 // the shadow region by copying live objects from source regions of the unavailable one. Once
2327 // the unavailable region becomes available, the data in the shadow region will be copied back.
2328 // Shadow regions are empty regions in the to-space and regions between top and end of other spaces.
2329 void PSParallelCompact::initialize_shadow_regions(uint parallel_gc_threads)
2330 {
2331 const ParallelCompactData& sd = PSParallelCompact::summary_data();
2332
2333 for (unsigned int id = old_space_id; id < last_space_id; ++id) {
2334 SpaceInfo* const space_info = _space_info + id;
2335 MutableSpace* const space = space_info->space();
2336
2337 const size_t beg_region =
2338 sd.addr_to_region_idx(sd.region_align_up(MAX2(space_info->new_top(), space->top())));
2339 const size_t end_region =
2340 sd.addr_to_region_idx(sd.region_align_down(space->end()));
2341
2342 for (size_t cur = beg_region; cur < end_region; ++cur) {
2343 ParCompactionManager::push_shadow_region(cur);
2344 }
2345 }
2346
2347 size_t beg_region = sd.addr_to_region_idx(_space_info[old_space_id].dense_prefix());
2348 for (uint i = 0; i < parallel_gc_threads; i++) {
2349 ParCompactionManager *cm = ParCompactionManager::gc_thread_compaction_manager(i);
2350 cm->set_next_shadow_region(beg_region + i);
2351 }
2352 }
2353
2354 void MoveAndUpdateClosure::copy_partial_obj(size_t partial_obj_size)
2355 {
2356 size_t words = MIN2(partial_obj_size, words_remaining());
2357
2358 // This test is necessary; if omitted, the pointer updates to a partial object
2359 // that crosses the dense prefix boundary could be overwritten.
2360 if (source() != copy_destination()) {
2361 DEBUG_ONLY(PSParallelCompact::check_new_location(source(), destination());)
2362 Copy::aligned_conjoint_words(source(), copy_destination(), words);
2363 }
2364 update_state(words);
2365 }
2366
2367 void MoveAndUpdateClosure::complete_region(HeapWord* dest_addr, PSParallelCompact::RegionData* region_ptr) {
2368 assert(region_ptr->shadow_state() == ParallelCompactData::RegionData::NormalRegion, "Region should be finished");
2369 region_ptr->set_completed();
2370 }
2371
2372 void MoveAndUpdateClosure::do_addr(HeapWord* addr, size_t words) {
2373 assert(destination() != nullptr, "sanity");
2374 _source = addr;
2375
2376 // The start_array must be updated even if the object is not moving.
2377 if (_start_array != nullptr) {
2378 _start_array->update_for_block(destination(), destination() + words);
2379 }
2380
2381 // Avoid overflow
2382 words = MIN2(words, words_remaining());
2383 assert(words > 0, "inv");
2384
2385 if (copy_destination() != source()) {
2386 DEBUG_ONLY(PSParallelCompact::check_new_location(source(), destination());)
2387 assert(source() != destination(), "inv");
2388 assert(FullGCForwarding::is_forwarded(cast_to_oop(source())), "inv");
2389 assert(FullGCForwarding::forwardee(cast_to_oop(source())) == cast_to_oop(destination()), "inv");
2390 Copy::aligned_conjoint_words(source(), copy_destination(), words);
2391 cast_to_oop(copy_destination())->reinit_mark();
2392 }
2393
2394 update_state(words);
2395 }
2396
2397 void MoveAndUpdateShadowClosure::complete_region(HeapWord* dest_addr, PSParallelCompact::RegionData* region_ptr) {
2398 assert(region_ptr->shadow_state() == ParallelCompactData::RegionData::ShadowRegion, "Region should be shadow");
2399 // Record the shadow region index
2400 region_ptr->set_shadow_region(_shadow);
2401 // Mark the shadow region as filled to indicate the data is ready to be
2402 // copied back
2403 region_ptr->mark_filled();
2404 // Try to copy the content of the shadow region back to its corresponding
2405 // heap region if available; the GC thread that decreases the destination
2406 // count to zero will do the copying otherwise (see
2407 // PSParallelCompact::decrement_destination_counts).
2408 if (((region_ptr->available() && region_ptr->claim()) || region_ptr->claimed()) && region_ptr->mark_copied()) {
2409 region_ptr->set_completed();
2410 PSParallelCompact::copy_back(PSParallelCompact::summary_data().region_to_addr(_shadow), dest_addr);
2411 ParCompactionManager::push_shadow_region_mt_safe(_shadow);
2412 }
2413 }