1 /*
2 * Copyright (c) 2005, 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
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 "gc/cms/concurrentMarkSweepGeneration.inline.hpp"
27 #include "gc/cms/concurrentMarkSweepThread.hpp"
28 #include "gc/cms/vmCMSOperations.hpp"
29 #include "gc/shared/gcLocker.inline.hpp"
30 #include "gc/shared/gcTimer.hpp"
31 #include "gc/shared/gcTraceTime.inline.hpp"
32 #include "gc/shared/isGCActiveMark.hpp"
33 #include "runtime/interfaceSupport.hpp"
34 #include "runtime/os.hpp"
35 #include "utilities/dtrace.hpp"
36
37 //////////////////////////////////////////////////////////
38 // Methods in abstract class VM_CMS_Operation
39 //////////////////////////////////////////////////////////
40 void VM_CMS_Operation::acquire_pending_list_lock() {
41 // The caller may block while communicating
42 // with the SLT thread in order to acquire/release the PLL.
43 SurrogateLockerThread* slt = ConcurrentMarkSweepThread::slt();
44 if (slt != NULL) {
45 slt->manipulatePLL(SurrogateLockerThread::acquirePLL);
46 } else {
47 SurrogateLockerThread::report_missing_slt();
48 }
49 }
50
51 void VM_CMS_Operation::release_and_notify_pending_list_lock() {
52 // The caller may block while communicating
53 // with the SLT thread in order to acquire/release the PLL.
54 ConcurrentMarkSweepThread::slt()->
55 manipulatePLL(SurrogateLockerThread::releaseAndNotifyPLL);
56 }
57
58 void VM_CMS_Operation::verify_before_gc() {
59 if (VerifyBeforeGC &&
60 GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) {
61 GCTraceTime(Info, gc, verify) tm("Verify Before", _collector->_gc_timer_cm);
62 HandleMark hm;
63 FreelistLocker x(_collector);
64 MutexLockerEx y(_collector->bitMapLock(), Mutex::_no_safepoint_check_flag);
65 GenCollectedHeap::heap()->prepare_for_verify();
66 Universe::verify();
67 }
68 }
69
70 void VM_CMS_Operation::verify_after_gc() {
71 if (VerifyAfterGC &&
72 GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) {
73 GCTraceTime(Info, gc, verify) tm("Verify After", _collector->_gc_timer_cm);
74 HandleMark hm;
75 FreelistLocker x(_collector);
78 }
79 }
80
81 bool VM_CMS_Operation::lost_race() const {
82 if (CMSCollector::abstract_state() == CMSCollector::Idling) {
83 // We lost a race to a foreground collection
84 // -- there's nothing to do
85 return true;
86 }
87 assert(CMSCollector::abstract_state() == legal_state(),
88 "Inconsistent collector state?");
89 return false;
90 }
91
92 bool VM_CMS_Operation::doit_prologue() {
93 assert(Thread::current()->is_ConcurrentGC_thread(), "just checking");
94 assert(!CMSCollector::foregroundGCShouldWait(), "Possible deadlock");
95 assert(!ConcurrentMarkSweepThread::cms_thread_has_cms_token(),
96 "Possible deadlock");
97
98 if (needs_pll()) {
99 acquire_pending_list_lock();
100 }
101 // Get the Heap_lock after the pending_list_lock.
102 Heap_lock->lock();
103 if (lost_race()) {
104 assert(_prologue_succeeded == false, "Initialized in c'tor");
105 Heap_lock->unlock();
106 if (needs_pll()) {
107 release_and_notify_pending_list_lock();
108 }
109 } else {
110 _prologue_succeeded = true;
111 }
112 return _prologue_succeeded;
113 }
114
115 void VM_CMS_Operation::doit_epilogue() {
116 assert(Thread::current()->is_ConcurrentGC_thread(), "just checking");
117 assert(!CMSCollector::foregroundGCShouldWait(), "Possible deadlock");
118 assert(!ConcurrentMarkSweepThread::cms_thread_has_cms_token(),
119 "Possible deadlock");
120
121 // Release the Heap_lock first.
122 Heap_lock->unlock();
123 if (needs_pll()) {
124 release_and_notify_pending_list_lock();
125 }
126 }
127
128 //////////////////////////////////////////////////////////
129 // Methods in class VM_CMS_Initial_Mark
130 //////////////////////////////////////////////////////////
131 void VM_CMS_Initial_Mark::doit() {
132 if (lost_race()) {
133 // Nothing to do.
134 return;
135 }
136 HS_PRIVATE_CMS_INITMARK_BEGIN();
137 GCIdMark gc_id_mark(_gc_id);
138
139 _collector->_gc_timer_cm->register_gc_pause_start("Initial Mark");
140
141 GenCollectedHeap* gch = GenCollectedHeap::heap();
142 GCCauseSetter gccs(gch, GCCause::_cms_initial_mark);
143
|
1 /*
2 * Copyright (c) 2005, 2016, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
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 "gc/cms/concurrentMarkSweepGeneration.inline.hpp"
27 #include "gc/cms/concurrentMarkSweepThread.hpp"
28 #include "gc/cms/vmCMSOperations.hpp"
29 #include "gc/shared/gcLocker.inline.hpp"
30 #include "gc/shared/gcTimer.hpp"
31 #include "gc/shared/gcTraceTime.inline.hpp"
32 #include "gc/shared/isGCActiveMark.hpp"
33 #include "runtime/interfaceSupport.hpp"
34 #include "runtime/os.hpp"
35 #include "utilities/dtrace.hpp"
36
37 //////////////////////////////////////////////////////////
38 // Methods in abstract class VM_CMS_Operation
39 //////////////////////////////////////////////////////////
40 void VM_CMS_Operation::acquire_pending_list_lock() {
41 _pending_list_locker.lock();
42 }
43
44 void VM_CMS_Operation::release_and_notify_pending_list_lock() {
45 _pending_list_locker.unlock();
46 }
47
48 void VM_CMS_Operation::verify_before_gc() {
49 if (VerifyBeforeGC &&
50 GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) {
51 GCTraceTime(Info, gc, verify) tm("Verify Before", _collector->_gc_timer_cm);
52 HandleMark hm;
53 FreelistLocker x(_collector);
54 MutexLockerEx y(_collector->bitMapLock(), Mutex::_no_safepoint_check_flag);
55 GenCollectedHeap::heap()->prepare_for_verify();
56 Universe::verify();
57 }
58 }
59
60 void VM_CMS_Operation::verify_after_gc() {
61 if (VerifyAfterGC &&
62 GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) {
63 GCTraceTime(Info, gc, verify) tm("Verify After", _collector->_gc_timer_cm);
64 HandleMark hm;
65 FreelistLocker x(_collector);
68 }
69 }
70
71 bool VM_CMS_Operation::lost_race() const {
72 if (CMSCollector::abstract_state() == CMSCollector::Idling) {
73 // We lost a race to a foreground collection
74 // -- there's nothing to do
75 return true;
76 }
77 assert(CMSCollector::abstract_state() == legal_state(),
78 "Inconsistent collector state?");
79 return false;
80 }
81
82 bool VM_CMS_Operation::doit_prologue() {
83 assert(Thread::current()->is_ConcurrentGC_thread(), "just checking");
84 assert(!CMSCollector::foregroundGCShouldWait(), "Possible deadlock");
85 assert(!ConcurrentMarkSweepThread::cms_thread_has_cms_token(),
86 "Possible deadlock");
87
88 if (needs_pending_list_lock()) {
89 acquire_pending_list_lock();
90 }
91 // Get the Heap_lock after the pending_list_lock.
92 Heap_lock->lock();
93 if (lost_race()) {
94 assert(_prologue_succeeded == false, "Initialized in c'tor");
95 Heap_lock->unlock();
96 if (needs_pending_list_lock()) {
97 release_and_notify_pending_list_lock();
98 }
99 } else {
100 _prologue_succeeded = true;
101 }
102 return _prologue_succeeded;
103 }
104
105 void VM_CMS_Operation::doit_epilogue() {
106 assert(Thread::current()->is_ConcurrentGC_thread(), "just checking");
107 assert(!CMSCollector::foregroundGCShouldWait(), "Possible deadlock");
108 assert(!ConcurrentMarkSweepThread::cms_thread_has_cms_token(),
109 "Possible deadlock");
110
111 // Release the Heap_lock first.
112 Heap_lock->unlock();
113 if (needs_pending_list_lock()) {
114 release_and_notify_pending_list_lock();
115 }
116 }
117
118 //////////////////////////////////////////////////////////
119 // Methods in class VM_CMS_Initial_Mark
120 //////////////////////////////////////////////////////////
121 void VM_CMS_Initial_Mark::doit() {
122 if (lost_race()) {
123 // Nothing to do.
124 return;
125 }
126 HS_PRIVATE_CMS_INITMARK_BEGIN();
127 GCIdMark gc_id_mark(_gc_id);
128
129 _collector->_gc_timer_cm->register_gc_pause_start("Initial Mark");
130
131 GenCollectedHeap* gch = GenCollectedHeap::heap();
132 GCCauseSetter gccs(gch, GCCause::_cms_initial_mark);
133
|