41 #include "gc_implementation/shared/gcHeapSummary.hpp"
42 #include "gc_implementation/shared/gcTimer.hpp"
43 #include "gc_implementation/shared/gcTrace.hpp"
44 #include "gc_implementation/shared/gcTraceTime.hpp"
45 #include "gc_implementation/shared/isGCActiveMark.hpp"
46 #include "gc_interface/gcCause.hpp"
47 #include "memory/gcLocker.inline.hpp"
48 #include "memory/referencePolicy.hpp"
49 #include "memory/referenceProcessor.hpp"
50 #include "oops/methodData.hpp"
51 #include "oops/oop.inline.hpp"
52 #include "oops/oop.pcgc.inline.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 "services/memTracker.hpp"
59 #include "utilities/events.hpp"
60 #include "utilities/stack.inline.hpp"
61
62 #include <math.h>
63
64 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
65
66 // All sizes are in HeapWords.
67 const size_t ParallelCompactData::Log2RegionSize = 16; // 64K words
68 const size_t ParallelCompactData::RegionSize = (size_t)1 << Log2RegionSize;
69 const size_t ParallelCompactData::RegionSizeBytes =
70 RegionSize << LogHeapWordSize;
71 const size_t ParallelCompactData::RegionSizeOffsetMask = RegionSize - 1;
72 const size_t ParallelCompactData::RegionAddrOffsetMask = RegionSizeBytes - 1;
73 const size_t ParallelCompactData::RegionAddrMask = ~RegionAddrOffsetMask;
74
75 const size_t ParallelCompactData::Log2BlockSize = 7; // 128 words
76 const size_t ParallelCompactData::BlockSize = (size_t)1 << Log2BlockSize;
77 const size_t ParallelCompactData::BlockSizeBytes =
78 BlockSize << LogHeapWordSize;
79 const size_t ParallelCompactData::BlockSizeOffsetMask = BlockSize - 1;
80 const size_t ParallelCompactData::BlockAddrOffsetMask = BlockSizeBytes - 1;
2454
2455 // Need new claim bits when tracing through and adjusting pointers.
2456 ClassLoaderDataGraph::clear_claimed_marks();
2457
2458 // General strong roots.
2459 Universe::oops_do(adjust_pointer_closure());
2460 JNIHandles::oops_do(adjust_pointer_closure()); // Global (strong) JNI handles
2461 CLDToOopClosure adjust_from_cld(adjust_pointer_closure());
2462 Threads::oops_do(adjust_pointer_closure(), &adjust_from_cld, NULL);
2463 ObjectSynchronizer::oops_do(adjust_pointer_closure());
2464 FlatProfiler::oops_do(adjust_pointer_closure());
2465 Management::oops_do(adjust_pointer_closure());
2466 JvmtiExport::oops_do(adjust_pointer_closure());
2467 SystemDictionary::oops_do(adjust_pointer_closure());
2468 ClassLoaderDataGraph::oops_do(adjust_pointer_closure(), adjust_klass_closure(), true);
2469
2470 // Now adjust pointers in remaining weak roots. (All of which should
2471 // have been cleared if they pointed to non-surviving objects.)
2472 // Global (weak) JNI handles
2473 JNIHandles::weak_oops_do(&always_true, adjust_pointer_closure());
2474
2475 CodeBlobToOopClosure adjust_from_blobs(adjust_pointer_closure(), CodeBlobToOopClosure::FixRelocations);
2476 CodeCache::blobs_do(&adjust_from_blobs);
2477 StringTable::oops_do(adjust_pointer_closure());
2478 ref_processor()->weak_oops_do(adjust_pointer_closure());
2479 // Roots were visited so references into the young gen in roots
2480 // may have been scanned. Process them also.
2481 // Should the reference processor have a span that excludes
2482 // young gen objects?
2483 PSScavenge::reference_processor()->weak_oops_do(adjust_pointer_closure());
2484 }
2485
2486 void PSParallelCompact::enqueue_region_draining_tasks(GCTaskQueue* q,
2487 uint parallel_gc_threads)
2488 {
2489 GCTraceTime tm("drain task setup", print_phases(), true, &_gc_timer, _gc_tracer.gc_id());
2490
2491 // Find the threads that are active
2492 unsigned int which = 0;
2493
|
41 #include "gc_implementation/shared/gcHeapSummary.hpp"
42 #include "gc_implementation/shared/gcTimer.hpp"
43 #include "gc_implementation/shared/gcTrace.hpp"
44 #include "gc_implementation/shared/gcTraceTime.hpp"
45 #include "gc_implementation/shared/isGCActiveMark.hpp"
46 #include "gc_interface/gcCause.hpp"
47 #include "memory/gcLocker.inline.hpp"
48 #include "memory/referencePolicy.hpp"
49 #include "memory/referenceProcessor.hpp"
50 #include "oops/methodData.hpp"
51 #include "oops/oop.inline.hpp"
52 #include "oops/oop.pcgc.inline.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 "services/memTracker.hpp"
59 #include "utilities/events.hpp"
60 #include "utilities/stack.inline.hpp"
61 #if INCLUDE_JFR
62 #include "jfr/jfr.hpp"
63 #endif // INCLUDE_JFR
64
65 #include <math.h>
66
67 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
68
69 // All sizes are in HeapWords.
70 const size_t ParallelCompactData::Log2RegionSize = 16; // 64K words
71 const size_t ParallelCompactData::RegionSize = (size_t)1 << Log2RegionSize;
72 const size_t ParallelCompactData::RegionSizeBytes =
73 RegionSize << LogHeapWordSize;
74 const size_t ParallelCompactData::RegionSizeOffsetMask = RegionSize - 1;
75 const size_t ParallelCompactData::RegionAddrOffsetMask = RegionSizeBytes - 1;
76 const size_t ParallelCompactData::RegionAddrMask = ~RegionAddrOffsetMask;
77
78 const size_t ParallelCompactData::Log2BlockSize = 7; // 128 words
79 const size_t ParallelCompactData::BlockSize = (size_t)1 << Log2BlockSize;
80 const size_t ParallelCompactData::BlockSizeBytes =
81 BlockSize << LogHeapWordSize;
82 const size_t ParallelCompactData::BlockSizeOffsetMask = BlockSize - 1;
83 const size_t ParallelCompactData::BlockAddrOffsetMask = BlockSizeBytes - 1;
2457
2458 // Need new claim bits when tracing through and adjusting pointers.
2459 ClassLoaderDataGraph::clear_claimed_marks();
2460
2461 // General strong roots.
2462 Universe::oops_do(adjust_pointer_closure());
2463 JNIHandles::oops_do(adjust_pointer_closure()); // Global (strong) JNI handles
2464 CLDToOopClosure adjust_from_cld(adjust_pointer_closure());
2465 Threads::oops_do(adjust_pointer_closure(), &adjust_from_cld, NULL);
2466 ObjectSynchronizer::oops_do(adjust_pointer_closure());
2467 FlatProfiler::oops_do(adjust_pointer_closure());
2468 Management::oops_do(adjust_pointer_closure());
2469 JvmtiExport::oops_do(adjust_pointer_closure());
2470 SystemDictionary::oops_do(adjust_pointer_closure());
2471 ClassLoaderDataGraph::oops_do(adjust_pointer_closure(), adjust_klass_closure(), true);
2472
2473 // Now adjust pointers in remaining weak roots. (All of which should
2474 // have been cleared if they pointed to non-surviving objects.)
2475 // Global (weak) JNI handles
2476 JNIHandles::weak_oops_do(&always_true, adjust_pointer_closure());
2477 JFR_ONLY(Jfr::weak_oops_do(&always_true, adjust_pointer_closure()));
2478
2479 CodeBlobToOopClosure adjust_from_blobs(adjust_pointer_closure(), CodeBlobToOopClosure::FixRelocations);
2480 CodeCache::blobs_do(&adjust_from_blobs);
2481 StringTable::oops_do(adjust_pointer_closure());
2482 ref_processor()->weak_oops_do(adjust_pointer_closure());
2483 // Roots were visited so references into the young gen in roots
2484 // may have been scanned. Process them also.
2485 // Should the reference processor have a span that excludes
2486 // young gen objects?
2487 PSScavenge::reference_processor()->weak_oops_do(adjust_pointer_closure());
2488 }
2489
2490 void PSParallelCompact::enqueue_region_draining_tasks(GCTaskQueue* q,
2491 uint parallel_gc_threads)
2492 {
2493 GCTraceTime tm("drain task setup", print_phases(), true, &_gc_timer, _gc_tracer.gc_id());
2494
2495 // Find the threads that are active
2496 unsigned int which = 0;
2497
|