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