< prev index next >

src/share/vm/gc/parallel/psMarkSweep.cpp

Print this page




  34 #include "gc/parallel/psMarkSweepDecorator.hpp"
  35 #include "gc/parallel/psOldGen.hpp"
  36 #include "gc/parallel/psScavenge.hpp"
  37 #include "gc/parallel/psYoungGen.hpp"
  38 #include "gc/serial/markSweep.hpp"
  39 #include "gc/shared/gcCause.hpp"
  40 #include "gc/shared/gcHeapSummary.hpp"
  41 #include "gc/shared/gcId.hpp"
  42 #include "gc/shared/gcLocker.inline.hpp"
  43 #include "gc/shared/gcTimer.hpp"
  44 #include "gc/shared/gcTrace.hpp"
  45 #include "gc/shared/gcTraceTime.inline.hpp"
  46 #include "gc/shared/isGCActiveMark.hpp"
  47 #include "gc/shared/referencePolicy.hpp"
  48 #include "gc/shared/referenceProcessor.hpp"
  49 #include "gc/shared/spaceDecorator.hpp"
  50 #include "logging/log.hpp"
  51 #include "oops/oop.inline.hpp"
  52 #include "runtime/biasedLocking.hpp"
  53 #include "runtime/fprofiler.hpp"

  54 #include "runtime/safepoint.hpp"
  55 #include "runtime/vmThread.hpp"
  56 #include "services/management.hpp"
  57 #include "services/memoryService.hpp"
  58 #include "utilities/events.hpp"
  59 #include "utilities/stack.inline.hpp"
  60 
  61 elapsedTimer        PSMarkSweep::_accumulated_time;
  62 jlong               PSMarkSweep::_time_of_last_gc   = 0;
  63 CollectorCounters*  PSMarkSweep::_counters = NULL;
  64 
  65 void PSMarkSweep::initialize() {
  66   MemRegion mr = ParallelScavengeHeap::heap()->reserved_region();
  67   set_ref_processor(new ReferenceProcessor(mr));     // a vanilla ref proc
  68   _counters = new CollectorCounters("PSMarkSweep", 1);
  69 }
  70 
  71 // This method contains all heap specific policy for invoking mark sweep.
  72 // PSMarkSweep::invoke_no_policy() will only attempt to mark-sweep-compact
  73 // the heap. It will do nothing further. If we need to bail out for policy


 593   PSOldGen* old_gen = heap->old_gen();
 594 
 595   // Need to clear claim bits before the tracing starts.
 596   ClassLoaderDataGraph::clear_claimed_marks();
 597 
 598   // General strong roots.
 599   Universe::oops_do(adjust_pointer_closure());
 600   JNIHandles::oops_do(adjust_pointer_closure());   // Global (strong) JNI handles
 601   Threads::oops_do(adjust_pointer_closure(), NULL);
 602   ObjectSynchronizer::oops_do(adjust_pointer_closure());
 603   FlatProfiler::oops_do(adjust_pointer_closure());
 604   Management::oops_do(adjust_pointer_closure());
 605   JvmtiExport::oops_do(adjust_pointer_closure());
 606   SystemDictionary::oops_do(adjust_pointer_closure());
 607   ClassLoaderDataGraph::cld_do(adjust_cld_closure());
 608 
 609   // Now adjust pointers in remaining weak roots.  (All of which should
 610   // have been cleared if they pointed to non-surviving objects.)
 611   // Global (weak) JNI handles
 612   JNIHandles::weak_oops_do(adjust_pointer_closure());

 613 
 614   CodeBlobToOopClosure adjust_from_blobs(adjust_pointer_closure(), CodeBlobToOopClosure::FixRelocations);
 615   CodeCache::blobs_do(&adjust_from_blobs);
 616   AOTLoader::oops_do(adjust_pointer_closure());
 617   StringTable::oops_do(adjust_pointer_closure());
 618   ref_processor()->weak_oops_do(adjust_pointer_closure());
 619   PSScavenge::reference_processor()->weak_oops_do(adjust_pointer_closure());
 620 
 621   adjust_marks();
 622 
 623   young_gen->adjust_pointers();
 624   old_gen->adjust_pointers();
 625 }
 626 
 627 void PSMarkSweep::mark_sweep_phase4() {
 628   EventMark m("4 compact heap");
 629   GCTraceTime(Info, gc, phases) tm("Phase 4: Move objects", _gc_timer);
 630 
 631   // All pointers are now adjusted, move objects accordingly
 632 




  34 #include "gc/parallel/psMarkSweepDecorator.hpp"
  35 #include "gc/parallel/psOldGen.hpp"
  36 #include "gc/parallel/psScavenge.hpp"
  37 #include "gc/parallel/psYoungGen.hpp"
  38 #include "gc/serial/markSweep.hpp"
  39 #include "gc/shared/gcCause.hpp"
  40 #include "gc/shared/gcHeapSummary.hpp"
  41 #include "gc/shared/gcId.hpp"
  42 #include "gc/shared/gcLocker.inline.hpp"
  43 #include "gc/shared/gcTimer.hpp"
  44 #include "gc/shared/gcTrace.hpp"
  45 #include "gc/shared/gcTraceTime.inline.hpp"
  46 #include "gc/shared/isGCActiveMark.hpp"
  47 #include "gc/shared/referencePolicy.hpp"
  48 #include "gc/shared/referenceProcessor.hpp"
  49 #include "gc/shared/spaceDecorator.hpp"
  50 #include "logging/log.hpp"
  51 #include "oops/oop.inline.hpp"
  52 #include "runtime/biasedLocking.hpp"
  53 #include "runtime/fprofiler.hpp"
  54 #include "runtime/heapMonitoring.hpp"
  55 #include "runtime/safepoint.hpp"
  56 #include "runtime/vmThread.hpp"
  57 #include "services/management.hpp"
  58 #include "services/memoryService.hpp"
  59 #include "utilities/events.hpp"
  60 #include "utilities/stack.inline.hpp"
  61 
  62 elapsedTimer        PSMarkSweep::_accumulated_time;
  63 jlong               PSMarkSweep::_time_of_last_gc   = 0;
  64 CollectorCounters*  PSMarkSweep::_counters = NULL;
  65 
  66 void PSMarkSweep::initialize() {
  67   MemRegion mr = ParallelScavengeHeap::heap()->reserved_region();
  68   set_ref_processor(new ReferenceProcessor(mr));     // a vanilla ref proc
  69   _counters = new CollectorCounters("PSMarkSweep", 1);
  70 }
  71 
  72 // This method contains all heap specific policy for invoking mark sweep.
  73 // PSMarkSweep::invoke_no_policy() will only attempt to mark-sweep-compact
  74 // the heap. It will do nothing further. If we need to bail out for policy


 594   PSOldGen* old_gen = heap->old_gen();
 595 
 596   // Need to clear claim bits before the tracing starts.
 597   ClassLoaderDataGraph::clear_claimed_marks();
 598 
 599   // General strong roots.
 600   Universe::oops_do(adjust_pointer_closure());
 601   JNIHandles::oops_do(adjust_pointer_closure());   // Global (strong) JNI handles
 602   Threads::oops_do(adjust_pointer_closure(), NULL);
 603   ObjectSynchronizer::oops_do(adjust_pointer_closure());
 604   FlatProfiler::oops_do(adjust_pointer_closure());
 605   Management::oops_do(adjust_pointer_closure());
 606   JvmtiExport::oops_do(adjust_pointer_closure());
 607   SystemDictionary::oops_do(adjust_pointer_closure());
 608   ClassLoaderDataGraph::cld_do(adjust_cld_closure());
 609 
 610   // Now adjust pointers in remaining weak roots.  (All of which should
 611   // have been cleared if they pointed to non-surviving objects.)
 612   // Global (weak) JNI handles
 613   JNIHandles::weak_oops_do(adjust_pointer_closure());
 614   HeapMonitoring::do_weak_oops(adjust_pointer_closure());
 615 
 616   CodeBlobToOopClosure adjust_from_blobs(adjust_pointer_closure(), CodeBlobToOopClosure::FixRelocations);
 617   CodeCache::blobs_do(&adjust_from_blobs);
 618   AOTLoader::oops_do(adjust_pointer_closure());
 619   StringTable::oops_do(adjust_pointer_closure());
 620   ref_processor()->weak_oops_do(adjust_pointer_closure());
 621   PSScavenge::reference_processor()->weak_oops_do(adjust_pointer_closure());
 622 
 623   adjust_marks();
 624 
 625   young_gen->adjust_pointers();
 626   old_gen->adjust_pointers();
 627 }
 628 
 629 void PSMarkSweep::mark_sweep_phase4() {
 630   EventMark m("4 compact heap");
 631   GCTraceTime(Info, gc, phases) tm("Phase 4: Move objects", _gc_timer);
 632 
 633   // All pointers are now adjusted, move objects accordingly
 634 


< prev index next >