57 #include "gc/shared/oopStorageSet.inline.hpp"
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/metaspaceUtils.hpp"
73 #include "memory/resourceArea.hpp"
74 #include "memory/universe.hpp"
75 #include "nmt/memTracker.hpp"
76 #include "oops/access.inline.hpp"
77 #include "oops/instanceClassLoaderKlass.inline.hpp"
78 #include "oops/instanceKlass.inline.hpp"
79 #include "oops/instanceMirrorKlass.inline.hpp"
80 #include "oops/methodData.hpp"
81 #include "oops/objArrayKlass.inline.hpp"
82 #include "oops/oop.inline.hpp"
83 #include "runtime/atomic.hpp"
84 #include "runtime/handles.inline.hpp"
85 #include "runtime/java.hpp"
86 #include "runtime/safepoint.hpp"
87 #include "runtime/threads.hpp"
88 #include "runtime/vmThread.hpp"
89 #include "services/memoryService.hpp"
90 #include "utilities/align.hpp"
91 #include "utilities/debug.hpp"
92 #include "utilities/events.hpp"
93 #include "utilities/formatBuffer.hpp"
94 #include "utilities/macros.hpp"
95 #include "utilities/stack.inline.hpp"
96 #if INCLUDE_JVMCI
2380 }
2381
2382 void MoveAndUpdateClosure::do_addr(HeapWord* addr, size_t words) {
2383 assert(destination() != nullptr, "sanity");
2384 _source = addr;
2385
2386 // The start_array must be updated even if the object is not moving.
2387 if (_start_array != nullptr) {
2388 _start_array->update_for_block(destination(), destination() + words);
2389 }
2390
2391 // Avoid overflow
2392 words = MIN2(words, words_remaining());
2393 assert(words > 0, "inv");
2394
2395 if (copy_destination() != source()) {
2396 DEBUG_ONLY(PSParallelCompact::check_new_location(source(), destination());)
2397 assert(source() != destination(), "inv");
2398 assert(cast_to_oop(source())->is_forwarded(), "inv");
2399 assert(cast_to_oop(source())->forwardee() == cast_to_oop(destination()), "inv");
2400 Copy::aligned_conjoint_words(source(), copy_destination(), words);
2401 cast_to_oop(copy_destination())->init_mark();
2402 }
2403
2404 update_state(words);
2405 }
2406
2407 void MoveAndUpdateShadowClosure::complete_region(HeapWord* dest_addr, PSParallelCompact::RegionData* region_ptr) {
2408 assert(region_ptr->shadow_state() == ParallelCompactData::RegionData::ShadowRegion, "Region should be shadow");
2409 // Record the shadow region index
2410 region_ptr->set_shadow_region(_shadow);
2411 // Mark the shadow region as filled to indicate the data is ready to be
2412 // copied back
2413 region_ptr->mark_filled();
2414 // Try to copy the content of the shadow region back to its corresponding
2415 // heap region if available; the GC thread that decreases the destination
2416 // count to zero will do the copying otherwise (see
2417 // PSParallelCompact::decrement_destination_counts).
2418 if (((region_ptr->available() && region_ptr->claim()) || region_ptr->claimed()) && region_ptr->mark_copied()) {
2419 region_ptr->set_completed();
2420 PSParallelCompact::copy_back(PSParallelCompact::summary_data().region_to_addr(_shadow), dest_addr);
2421 ParCompactionManager::push_shadow_region_mt_safe(_shadow);
|
57 #include "gc/shared/oopStorageSet.inline.hpp"
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/metaspaceUtils.hpp"
73 #include "memory/resourceArea.hpp"
74 #include "memory/universe.hpp"
75 #include "nmt/memTracker.hpp"
76 #include "oops/access.inline.hpp"
77 #include "oops/flatArrayKlass.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
2381 }
2382
2383 void MoveAndUpdateClosure::do_addr(HeapWord* addr, size_t words) {
2384 assert(destination() != nullptr, "sanity");
2385 _source = addr;
2386
2387 // The start_array must be updated even if the object is not moving.
2388 if (_start_array != nullptr) {
2389 _start_array->update_for_block(destination(), destination() + words);
2390 }
2391
2392 // Avoid overflow
2393 words = MIN2(words, words_remaining());
2394 assert(words > 0, "inv");
2395
2396 if (copy_destination() != source()) {
2397 DEBUG_ONLY(PSParallelCompact::check_new_location(source(), destination());)
2398 assert(source() != destination(), "inv");
2399 assert(cast_to_oop(source())->is_forwarded(), "inv");
2400 assert(cast_to_oop(source())->forwardee() == cast_to_oop(destination()), "inv");
2401 // Read the klass before the copying, since it might destroy the klass (i.e. overlapping copy)
2402 // and if partial copy, the destination klass may not be copied yet
2403 Klass* klass = cast_to_oop(source())->klass();
2404 Copy::aligned_conjoint_words(source(), copy_destination(), words);
2405 cast_to_oop(copy_destination())->set_mark(Klass::default_prototype_header(klass));
2406 }
2407
2408 update_state(words);
2409 }
2410
2411 void MoveAndUpdateShadowClosure::complete_region(HeapWord* dest_addr, PSParallelCompact::RegionData* region_ptr) {
2412 assert(region_ptr->shadow_state() == ParallelCompactData::RegionData::ShadowRegion, "Region should be shadow");
2413 // Record the shadow region index
2414 region_ptr->set_shadow_region(_shadow);
2415 // Mark the shadow region as filled to indicate the data is ready to be
2416 // copied back
2417 region_ptr->mark_filled();
2418 // Try to copy the content of the shadow region back to its corresponding
2419 // heap region if available; the GC thread that decreases the destination
2420 // count to zero will do the copying otherwise (see
2421 // PSParallelCompact::decrement_destination_counts).
2422 if (((region_ptr->available() && region_ptr->claim()) || region_ptr->claimed()) && region_ptr->mark_copied()) {
2423 region_ptr->set_completed();
2424 PSParallelCompact::copy_back(PSParallelCompact::summary_data().region_to_addr(_shadow), dest_addr);
2425 ParCompactionManager::push_shadow_region_mt_safe(_shadow);
|