< prev index next >

src/hotspot/share/gc/parallel/psParallelCompact.cpp

Print this page

  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);
< prev index next >