20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "code/codeCache.hpp"
27 #include "gc/g1/g1CollectedHeap.hpp"
28 #include "gc/g1/g1CollectorPolicy.hpp"
29 #include "gc/g1/g1FullCollector.hpp"
30 #include "gc/g1/g1FullGCAdjustTask.hpp"
31 #include "gc/g1/g1FullGCCompactTask.hpp"
32 #include "gc/g1/g1FullGCMarker.inline.hpp"
33 #include "gc/g1/g1FullGCMarkTask.hpp"
34 #include "gc/g1/g1FullGCPrepareTask.hpp"
35 #include "gc/g1/g1FullGCReferenceProcessorExecutor.hpp"
36 #include "gc/g1/g1FullGCScope.hpp"
37 #include "gc/g1/g1OopClosures.hpp"
38 #include "gc/g1/g1Policy.hpp"
39 #include "gc/g1/g1StringDedup.hpp"
40 #include "gc/shared/gcTraceTime.inline.hpp"
41 #include "gc/shared/preservedMarks.hpp"
42 #include "gc/shared/referenceProcessor.hpp"
43 #include "gc/shared/weakProcessor.hpp"
44 #include "logging/log.hpp"
45 #include "runtime/biasedLocking.hpp"
46 #include "runtime/handles.inline.hpp"
47 #include "utilities/debug.hpp"
48
49 static void clear_and_activate_derived_pointers() {
50 #if COMPILER2_OR_JVMCI
51 DerivedPointerTable::clear();
52 #endif
53 }
54
55 static void deactivate_derived_pointers() {
56 #if COMPILER2_OR_JVMCI
57 DerivedPointerTable::set_active(false);
58 #endif
59 }
60
61 static void update_derived_pointers() {
62 #if COMPILER2_OR_JVMCI
63 DerivedPointerTable::update_pointers();
64 #endif
65 }
66
67 G1CMBitMap* G1FullCollector::mark_bitmap() {
68 return _heap->concurrent_mark()->next_mark_bitmap();
69 }
70
71 ReferenceProcessor* G1FullCollector::reference_processor() {
72 return _heap->ref_processor_stw();
73 }
74
75 G1FullCollector::G1FullCollector(G1CollectedHeap* heap, GCMemoryManager* memory_manager, bool explicit_gc, bool clear_soft_refs) :
76 _heap(heap),
77 _scope(memory_manager, explicit_gc, clear_soft_refs),
78 _num_workers(heap->workers()->active_workers()),
79 _oop_queue_set(_num_workers),
80 _array_queue_set(_num_workers),
81 _preserved_marks_set(true),
82 _serial_compaction_point(),
83 _is_alive(heap->concurrent_mark()->next_mark_bitmap()),
84 _is_alive_mutator(heap->ref_processor_stw(), &_is_alive) {
85 assert(SafepointSynchronize::is_at_safepoint(), "must be at a safepoint");
86
87 _preserved_marks_set.init(_num_workers);
88 _markers = NEW_C_HEAP_ARRAY(G1FullGCMarker*, _num_workers, mtGC);
89 _compaction_points = NEW_C_HEAP_ARRAY(G1FullGCCompactionPoint*, _num_workers, mtGC);
90 for (uint i = 0; i < _num_workers; i++) {
91 _markers[i] = new G1FullGCMarker(i, _preserved_marks_set.get(i), mark_bitmap());
92 _compaction_points[i] = new G1FullGCCompactionPoint();
93 _oop_queue_set.register_queue(i, marker(i)->oop_stack());
94 _array_queue_set.register_queue(i, marker(i)->objarray_stack());
95 }
96 }
97
98 G1FullCollector::~G1FullCollector() {
|
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "code/codeCache.hpp"
27 #include "gc/g1/g1CollectedHeap.hpp"
28 #include "gc/g1/g1CollectorPolicy.hpp"
29 #include "gc/g1/g1FullCollector.hpp"
30 #include "gc/g1/g1FullGCAdjustTask.hpp"
31 #include "gc/g1/g1FullGCCompactTask.hpp"
32 #include "gc/g1/g1FullGCMarker.inline.hpp"
33 #include "gc/g1/g1FullGCMarkTask.hpp"
34 #include "gc/g1/g1FullGCPrepareTask.hpp"
35 #include "gc/g1/g1FullGCReferenceProcessorExecutor.hpp"
36 #include "gc/g1/g1FullGCScope.hpp"
37 #include "gc/g1/g1OopClosures.hpp"
38 #include "gc/g1/g1Policy.hpp"
39 #include "gc/g1/g1StringDedup.hpp"
40 #include "gc/shared/adaptiveSizePolicy.hpp"
41 #include "gc/shared/gcTraceTime.inline.hpp"
42 #include "gc/shared/preservedMarks.hpp"
43 #include "gc/shared/referenceProcessor.hpp"
44 #include "gc/shared/weakProcessor.hpp"
45 #include "logging/log.hpp"
46 #include "runtime/biasedLocking.hpp"
47 #include "runtime/handles.inline.hpp"
48 #include "utilities/debug.hpp"
49
50 static void clear_and_activate_derived_pointers() {
51 #if COMPILER2_OR_JVMCI
52 DerivedPointerTable::clear();
53 #endif
54 }
55
56 static void deactivate_derived_pointers() {
57 #if COMPILER2_OR_JVMCI
58 DerivedPointerTable::set_active(false);
59 #endif
60 }
61
62 static void update_derived_pointers() {
63 #if COMPILER2_OR_JVMCI
64 DerivedPointerTable::update_pointers();
65 #endif
66 }
67
68 G1CMBitMap* G1FullCollector::mark_bitmap() {
69 return _heap->concurrent_mark()->next_mark_bitmap();
70 }
71
72 ReferenceProcessor* G1FullCollector::reference_processor() {
73 return _heap->ref_processor_stw();
74 }
75
76 uint G1FullCollector::calc_active_workers() {
77 G1CollectedHeap* heap = G1CollectedHeap::heap();
78 uint max_worker_count = heap->workers()->total_workers();
79 // Only calculate number of workers if UseDynamicNumberOfGCThreads
80 // is enabled, otherwise use max.
81 if (!UseDynamicNumberOfGCThreads) {
82 return max_worker_count;
83 }
84
85 // Consider G1HeapWastePercent to decide max number of workers. Each worker
86 // will in average cause half a region waste.
87 uint max_wasted_regions_allowed = ((heap->num_regions() * G1HeapWastePercent) / 100);
88 uint waste_worker_count = MAX2((max_wasted_regions_allowed * 2) , 1u);
89 uint heap_waste_worker_limit = MIN2(waste_worker_count, max_worker_count);
90
91 // Also consider HeapSizePerGCThread by calling AdaptiveSizePolicy to calculate
92 // the number of workers.
93 uint current_active_workers = heap->workers()->active_workers();
94 uint adaptive_worker_limit = AdaptiveSizePolicy::calc_active_workers(max_worker_count, current_active_workers, 0);
95
96 // Update active workers to the lower of the limits.
97 uint worker_count = MIN2(heap_waste_worker_limit, adaptive_worker_limit);
98 log_debug(gc, task)("Requesting %u active workers for full compaction (waste limited workers: %u, adaptive workers: %u)",
99 worker_count, heap_waste_worker_limit, adaptive_worker_limit);
100 worker_count = heap->workers()->update_active_workers(worker_count);
101 log_info(gc, task)("Using %u workers of %u for full compaction", worker_count, max_worker_count);
102
103 return worker_count;
104 }
105
106 G1FullCollector::G1FullCollector(G1CollectedHeap* heap, GCMemoryManager* memory_manager, bool explicit_gc, bool clear_soft_refs) :
107 _heap(heap),
108 _scope(memory_manager, explicit_gc, clear_soft_refs),
109 _num_workers(calc_active_workers()),
110 _oop_queue_set(_num_workers),
111 _array_queue_set(_num_workers),
112 _preserved_marks_set(true),
113 _serial_compaction_point(),
114 _is_alive(heap->concurrent_mark()->next_mark_bitmap()),
115 _is_alive_mutator(heap->ref_processor_stw(), &_is_alive) {
116 assert(SafepointSynchronize::is_at_safepoint(), "must be at a safepoint");
117
118 _preserved_marks_set.init(_num_workers);
119 _markers = NEW_C_HEAP_ARRAY(G1FullGCMarker*, _num_workers, mtGC);
120 _compaction_points = NEW_C_HEAP_ARRAY(G1FullGCCompactionPoint*, _num_workers, mtGC);
121 for (uint i = 0; i < _num_workers; i++) {
122 _markers[i] = new G1FullGCMarker(i, _preserved_marks_set.get(i), mark_bitmap());
123 _compaction_points[i] = new G1FullGCCompactionPoint();
124 _oop_queue_set.register_queue(i, marker(i)->oop_stack());
125 _array_queue_set.register_queue(i, marker(i)->objarray_stack());
126 }
127 }
128
129 G1FullCollector::~G1FullCollector() {
|