< prev index next >

src/hotspot/share/gc/g1/g1CollectedHeap.cpp

Print this page

  69 #include "gc/g1/g1Trace.hpp"
  70 #include "gc/g1/g1UncommitRegionTask.hpp"
  71 #include "gc/g1/g1VMOperations.hpp"
  72 #include "gc/g1/g1YoungCollector.hpp"
  73 #include "gc/g1/g1YoungGCAllocationFailureInjector.hpp"
  74 #include "gc/g1/heapRegion.inline.hpp"
  75 #include "gc/g1/heapRegionRemSet.inline.hpp"
  76 #include "gc/g1/heapRegionSet.inline.hpp"
  77 #include "gc/shared/classUnloadingContext.hpp"
  78 #include "gc/shared/concurrentGCBreakpoints.hpp"
  79 #include "gc/shared/gcBehaviours.hpp"
  80 #include "gc/shared/gcHeapSummary.hpp"
  81 #include "gc/shared/gcId.hpp"
  82 #include "gc/shared/gcTimer.hpp"
  83 #include "gc/shared/gcTraceTime.inline.hpp"
  84 #include "gc/shared/isGCActiveMark.hpp"
  85 #include "gc/shared/locationPrinter.inline.hpp"
  86 #include "gc/shared/oopStorageParState.hpp"
  87 #include "gc/shared/preservedMarks.inline.hpp"
  88 #include "gc/shared/referenceProcessor.inline.hpp"

  89 #include "gc/shared/suspendibleThreadSet.hpp"
  90 #include "gc/shared/taskqueue.inline.hpp"
  91 #include "gc/shared/taskTerminator.hpp"
  92 #include "gc/shared/tlab_globals.hpp"
  93 #include "gc/shared/workerPolicy.hpp"
  94 #include "gc/shared/weakProcessor.inline.hpp"
  95 #include "logging/log.hpp"
  96 #include "memory/allocation.hpp"
  97 #include "memory/heapInspection.hpp"
  98 #include "memory/iterator.hpp"
  99 #include "memory/metaspaceUtils.hpp"
 100 #include "memory/resourceArea.hpp"
 101 #include "memory/universe.hpp"
 102 #include "oops/access.inline.hpp"
 103 #include "oops/compressedOops.inline.hpp"
 104 #include "oops/oop.inline.hpp"
 105 #include "runtime/atomic.hpp"
 106 #include "runtime/cpuTimeCounters.hpp"
 107 #include "runtime/handles.inline.hpp"
 108 #include "runtime/init.hpp"

1423   dummy_region->set_top(dummy_region->end());
1424   G1AllocRegion::setup(this, dummy_region);
1425 
1426   _allocator->init_mutator_alloc_regions();
1427 
1428   // Do create of the monitoring and management support so that
1429   // values in the heap have been properly initialized.
1430   _monitoring_support = new G1MonitoringSupport(this);
1431 
1432   _collection_set.initialize(max_reserved_regions());
1433 
1434   allocation_failure_injector()->reset();
1435 
1436   CPUTimeCounters::create_counter(CPUTimeGroups::CPUTimeType::gc_parallel_workers);
1437   CPUTimeCounters::create_counter(CPUTimeGroups::CPUTimeType::gc_conc_mark);
1438   CPUTimeCounters::create_counter(CPUTimeGroups::CPUTimeType::gc_conc_refine);
1439   CPUTimeCounters::create_counter(CPUTimeGroups::CPUTimeType::gc_service);
1440 
1441   G1InitLogger::print();
1442 


1443   return JNI_OK;
1444 }
1445 
1446 bool G1CollectedHeap::concurrent_mark_is_terminating() const {
1447   return _cm_thread->should_terminate();
1448 }
1449 
1450 void G1CollectedHeap::stop() {
1451   // Stop all concurrent threads. We do this to make sure these threads
1452   // do not continue to execute and access resources (e.g. logging)
1453   // that are destroyed during shutdown.
1454   _cr->stop();
1455   _service_thread->stop();
1456   _cm_thread->stop();
1457 }
1458 
1459 void G1CollectedHeap::safepoint_synchronize_begin() {
1460   SuspendibleThreadSet::synchronize();
1461 }
1462 

  69 #include "gc/g1/g1Trace.hpp"
  70 #include "gc/g1/g1UncommitRegionTask.hpp"
  71 #include "gc/g1/g1VMOperations.hpp"
  72 #include "gc/g1/g1YoungCollector.hpp"
  73 #include "gc/g1/g1YoungGCAllocationFailureInjector.hpp"
  74 #include "gc/g1/heapRegion.inline.hpp"
  75 #include "gc/g1/heapRegionRemSet.inline.hpp"
  76 #include "gc/g1/heapRegionSet.inline.hpp"
  77 #include "gc/shared/classUnloadingContext.hpp"
  78 #include "gc/shared/concurrentGCBreakpoints.hpp"
  79 #include "gc/shared/gcBehaviours.hpp"
  80 #include "gc/shared/gcHeapSummary.hpp"
  81 #include "gc/shared/gcId.hpp"
  82 #include "gc/shared/gcTimer.hpp"
  83 #include "gc/shared/gcTraceTime.inline.hpp"
  84 #include "gc/shared/isGCActiveMark.hpp"
  85 #include "gc/shared/locationPrinter.inline.hpp"
  86 #include "gc/shared/oopStorageParState.hpp"
  87 #include "gc/shared/preservedMarks.inline.hpp"
  88 #include "gc/shared/referenceProcessor.inline.hpp"
  89 #include "gc/shared/slidingForwarding.hpp"
  90 #include "gc/shared/suspendibleThreadSet.hpp"
  91 #include "gc/shared/taskqueue.inline.hpp"
  92 #include "gc/shared/taskTerminator.hpp"
  93 #include "gc/shared/tlab_globals.hpp"
  94 #include "gc/shared/workerPolicy.hpp"
  95 #include "gc/shared/weakProcessor.inline.hpp"
  96 #include "logging/log.hpp"
  97 #include "memory/allocation.hpp"
  98 #include "memory/heapInspection.hpp"
  99 #include "memory/iterator.hpp"
 100 #include "memory/metaspaceUtils.hpp"
 101 #include "memory/resourceArea.hpp"
 102 #include "memory/universe.hpp"
 103 #include "oops/access.inline.hpp"
 104 #include "oops/compressedOops.inline.hpp"
 105 #include "oops/oop.inline.hpp"
 106 #include "runtime/atomic.hpp"
 107 #include "runtime/cpuTimeCounters.hpp"
 108 #include "runtime/handles.inline.hpp"
 109 #include "runtime/init.hpp"

1424   dummy_region->set_top(dummy_region->end());
1425   G1AllocRegion::setup(this, dummy_region);
1426 
1427   _allocator->init_mutator_alloc_regions();
1428 
1429   // Do create of the monitoring and management support so that
1430   // values in the heap have been properly initialized.
1431   _monitoring_support = new G1MonitoringSupport(this);
1432 
1433   _collection_set.initialize(max_reserved_regions());
1434 
1435   allocation_failure_injector()->reset();
1436 
1437   CPUTimeCounters::create_counter(CPUTimeGroups::CPUTimeType::gc_parallel_workers);
1438   CPUTimeCounters::create_counter(CPUTimeGroups::CPUTimeType::gc_conc_mark);
1439   CPUTimeCounters::create_counter(CPUTimeGroups::CPUTimeType::gc_conc_refine);
1440   CPUTimeCounters::create_counter(CPUTimeGroups::CPUTimeType::gc_service);
1441 
1442   G1InitLogger::print();
1443 
1444   SlidingForwarding::initialize(heap_rs.region(), HeapRegion::GrainWords);
1445 
1446   return JNI_OK;
1447 }
1448 
1449 bool G1CollectedHeap::concurrent_mark_is_terminating() const {
1450   return _cm_thread->should_terminate();
1451 }
1452 
1453 void G1CollectedHeap::stop() {
1454   // Stop all concurrent threads. We do this to make sure these threads
1455   // do not continue to execute and access resources (e.g. logging)
1456   // that are destroyed during shutdown.
1457   _cr->stop();
1458   _service_thread->stop();
1459   _cm_thread->stop();
1460 }
1461 
1462 void G1CollectedHeap::safepoint_synchronize_begin() {
1463   SuspendibleThreadSet::synchronize();
1464 }
1465 
< prev index next >