58 #include "gc/shared/oopStorageSetParState.inline.hpp"
59 #include "gc/shared/preservedMarks.inline.hpp"
60 #include "gc/shared/referencePolicy.hpp"
61 #include "gc/shared/referenceProcessor.hpp"
62 #include "gc/shared/referenceProcessorPhaseTimes.hpp"
63 #include "gc/shared/spaceDecorator.hpp"
64 #include "gc/shared/strongRootsScope.hpp"
65 #include "gc/shared/taskTerminator.hpp"
66 #include "gc/shared/weakProcessor.inline.hpp"
67 #include "gc/shared/workerPolicy.hpp"
68 #include "gc/shared/workerThread.hpp"
69 #include "gc/shared/workerUtils.hpp"
70 #include "logging/log.hpp"
71 #include "memory/iterator.inline.hpp"
72 #include "memory/memoryReserver.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
2434 }
2435
2436 void MoveAndUpdateClosure::do_addr(HeapWord* addr, size_t words) {
2437 assert(destination() != nullptr, "sanity");
2438 _source = addr;
2439
2440 // The start_array must be updated even if the object is not moving.
2441 if (_start_array != nullptr) {
2442 _start_array->update_for_block(destination(), destination() + words);
2443 }
2444
2445 // Avoid overflow
2446 words = MIN2(words, words_remaining());
2447 assert(words > 0, "inv");
2448
2449 if (copy_destination() != source()) {
2450 DEBUG_ONLY(PSParallelCompact::check_new_location(source(), destination());)
2451 assert(source() != destination(), "inv");
2452 assert(FullGCForwarding::is_forwarded(cast_to_oop(source())), "inv");
2453 assert(FullGCForwarding::forwardee(cast_to_oop(source())) == cast_to_oop(destination()), "inv");
2454 Copy::aligned_conjoint_words(source(), copy_destination(), words);
2455 cast_to_oop(copy_destination())->init_mark();
2456 }
2457
2458 update_state(words);
2459 }
2460
2461 void MoveAndUpdateShadowClosure::complete_region(HeapWord* dest_addr, PSParallelCompact::RegionData* region_ptr) {
2462 assert(region_ptr->shadow_state() == ParallelCompactData::RegionData::ShadowRegion, "Region should be shadow");
2463 // Record the shadow region index
2464 region_ptr->set_shadow_region(_shadow);
2465 // Mark the shadow region as filled to indicate the data is ready to be
2466 // copied back
2467 region_ptr->mark_filled();
2468 // Try to copy the content of the shadow region back to its corresponding
2469 // heap region if available; the GC thread that decreases the destination
2470 // count to zero will do the copying otherwise (see
2471 // PSParallelCompact::decrement_destination_counts).
2472 if (((region_ptr->available() && region_ptr->claim()) || region_ptr->claimed()) && region_ptr->mark_copied()) {
2473 region_ptr->set_completed();
2474 PSParallelCompact::copy_back(PSParallelCompact::summary_data().region_to_addr(_shadow), dest_addr);
2475 ParCompactionManager::push_shadow_region_mt_safe(_shadow);
|
58 #include "gc/shared/oopStorageSetParState.inline.hpp"
59 #include "gc/shared/preservedMarks.inline.hpp"
60 #include "gc/shared/referencePolicy.hpp"
61 #include "gc/shared/referenceProcessor.hpp"
62 #include "gc/shared/referenceProcessorPhaseTimes.hpp"
63 #include "gc/shared/spaceDecorator.hpp"
64 #include "gc/shared/strongRootsScope.hpp"
65 #include "gc/shared/taskTerminator.hpp"
66 #include "gc/shared/weakProcessor.inline.hpp"
67 #include "gc/shared/workerPolicy.hpp"
68 #include "gc/shared/workerThread.hpp"
69 #include "gc/shared/workerUtils.hpp"
70 #include "logging/log.hpp"
71 #include "memory/iterator.inline.hpp"
72 #include "memory/memoryReserver.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/flatArrayKlass.inline.hpp"
79 #include "oops/instanceClassLoaderKlass.inline.hpp"
80 #include "oops/instanceKlass.inline.hpp"
81 #include "oops/instanceMirrorKlass.inline.hpp"
82 #include "oops/methodData.hpp"
83 #include "oops/objArrayKlass.inline.hpp"
84 #include "oops/oop.inline.hpp"
85 #include "runtime/atomic.hpp"
86 #include "runtime/handles.inline.hpp"
87 #include "runtime/java.hpp"
88 #include "runtime/safepoint.hpp"
89 #include "runtime/threads.hpp"
90 #include "runtime/vmThread.hpp"
91 #include "services/memoryService.hpp"
92 #include "utilities/align.hpp"
93 #include "utilities/debug.hpp"
94 #include "utilities/events.hpp"
95 #include "utilities/formatBuffer.hpp"
96 #include "utilities/macros.hpp"
97 #include "utilities/stack.inline.hpp"
98 #if INCLUDE_JVMCI
2435 }
2436
2437 void MoveAndUpdateClosure::do_addr(HeapWord* addr, size_t words) {
2438 assert(destination() != nullptr, "sanity");
2439 _source = addr;
2440
2441 // The start_array must be updated even if the object is not moving.
2442 if (_start_array != nullptr) {
2443 _start_array->update_for_block(destination(), destination() + words);
2444 }
2445
2446 // Avoid overflow
2447 words = MIN2(words, words_remaining());
2448 assert(words > 0, "inv");
2449
2450 if (copy_destination() != source()) {
2451 DEBUG_ONLY(PSParallelCompact::check_new_location(source(), destination());)
2452 assert(source() != destination(), "inv");
2453 assert(FullGCForwarding::is_forwarded(cast_to_oop(source())), "inv");
2454 assert(FullGCForwarding::forwardee(cast_to_oop(source())) == cast_to_oop(destination()), "inv");
2455 // Read the klass before the copying, since it might destroy the klass (i.e. overlapping copy)
2456 // and if partial copy, the destination klass may not be copied yet
2457 Klass* klass = cast_to_oop(source())->klass();
2458 Copy::aligned_conjoint_words(source(), copy_destination(), words);
2459 cast_to_oop(copy_destination())->set_mark(Klass::default_prototype_header(klass));
2460 }
2461
2462 update_state(words);
2463 }
2464
2465 void MoveAndUpdateShadowClosure::complete_region(HeapWord* dest_addr, PSParallelCompact::RegionData* region_ptr) {
2466 assert(region_ptr->shadow_state() == ParallelCompactData::RegionData::ShadowRegion, "Region should be shadow");
2467 // Record the shadow region index
2468 region_ptr->set_shadow_region(_shadow);
2469 // Mark the shadow region as filled to indicate the data is ready to be
2470 // copied back
2471 region_ptr->mark_filled();
2472 // Try to copy the content of the shadow region back to its corresponding
2473 // heap region if available; the GC thread that decreases the destination
2474 // count to zero will do the copying otherwise (see
2475 // PSParallelCompact::decrement_destination_counts).
2476 if (((region_ptr->available() && region_ptr->claim()) || region_ptr->claimed()) && region_ptr->mark_copied()) {
2477 region_ptr->set_completed();
2478 PSParallelCompact::copy_back(PSParallelCompact::summary_data().region_to_addr(_shadow), dest_addr);
2479 ParCompactionManager::push_shadow_region_mt_safe(_shadow);
|