16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 *
24 */
25
26 #include "code/codeCache.hpp"
27 #include "code/nmethod.hpp"
28 #include "gc/shared/classUnloadingContext.hpp"
29 #include "gc/shenandoah/shenandoahClosures.inline.hpp"
30 #include "gc/shenandoah/shenandoahHeap.inline.hpp"
31 #include "gc/shenandoah/shenandoahNMethod.inline.hpp"
32 #include "gc/shenandoah/shenandoahUtils.hpp"
33 #include "memory/resourceArea.hpp"
34 #include "memory/universe.hpp"
35 #include "runtime/atomicAccess.hpp"
36 #include "utilities/powerOfTwo.hpp"
37
38
39 ShenandoahNMethodTable* ShenandoahCodeRoots::_nmethod_table;
40 int ShenandoahCodeRoots::_disarmed_value = 1;
41
42 void ShenandoahCodeRoots::initialize() {
43 _nmethod_table = new ShenandoahNMethodTable();
44 }
45
46 void ShenandoahCodeRoots::register_nmethod(nmethod* nm) {
47 assert(CodeCache_lock->owned_by_self(), "Must have CodeCache_lock held");
48 _nmethod_table->register_nmethod(nm);
49 }
50
51 void ShenandoahCodeRoots::unregister_nmethod(nmethod* nm) {
52 assert_locked_or_safepoint(CodeCache_lock);
53 _nmethod_table->unregister_nmethod(nm);
54 }
55
56 void ShenandoahCodeRoots::arm_nmethods() {
57 BarrierSet::barrier_set()->barrier_set_nmethod()->arm_all_nmethods();
58 }
59
60 class ShenandoahDisarmNMethodClosure : public NMethodClosure {
61 public:
62 virtual void do_nmethod(nmethod* nm) {
63 ShenandoahNMethod::disarm_nmethod(nm);
64 }
65 };
66
67 class ShenandoahDisarmNMethodsTask : public WorkerTask {
68 private:
69 ShenandoahDisarmNMethodClosure _cl;
70 ShenandoahConcurrentNMethodIterator _iterator;
71
72 public:
73 ShenandoahDisarmNMethodsTask() :
74 WorkerTask("Shenandoah Disarm NMethods"),
75 _iterator(ShenandoahCodeRoots::table()) {
76 assert(SafepointSynchronize::is_at_safepoint(), "Only at a safepoint");
77 }
78
79 virtual void work(uint worker_id) {
80 ShenandoahParallelWorkerSession worker_session(worker_id);
81 _iterator.nmethods_do(&_cl);
82 }
83 };
84
85 void ShenandoahCodeRoots::disarm_nmethods() {
86 ShenandoahDisarmNMethodsTask task;
87 ShenandoahHeap::heap()->workers()->run_task(&task);
88 }
89
90 class ShenandoahNMethodUnlinkClosure : public NMethodClosure {
91 private:
92 bool _unloading_occurred;
93 ShenandoahHeap* const _heap;
94 BarrierSetNMethod* const _bs;
95
96 public:
97 ShenandoahNMethodUnlinkClosure(bool unloading_occurred) :
98 _unloading_occurred(unloading_occurred),
99 _heap(ShenandoahHeap::heap()),
100 _bs(ShenandoahBarrierSet::barrier_set()->barrier_set_nmethod()) {}
101
102 virtual void do_nmethod(nmethod* nm) {
103 assert(_heap->is_concurrent_weak_root_in_progress(), "Only this phase");
104
105 ShenandoahNMethod* nm_data = ShenandoahNMethod::gc_data(nm);
106 assert(!nm_data->is_unregistered(), "Should not see unregistered entry");
107
108 if (nm->is_unloading()) {
109 ShenandoahNMethodLocker locker(nm_data->lock());
|
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 *
24 */
25
26 #include "code/codeCache.hpp"
27 #include "code/nmethod.hpp"
28 #include "gc/shared/classUnloadingContext.hpp"
29 #include "gc/shenandoah/shenandoahClosures.inline.hpp"
30 #include "gc/shenandoah/shenandoahHeap.inline.hpp"
31 #include "gc/shenandoah/shenandoahNMethod.inline.hpp"
32 #include "gc/shenandoah/shenandoahUtils.hpp"
33 #include "memory/resourceArea.hpp"
34 #include "memory/universe.hpp"
35 #include "runtime/atomicAccess.hpp"
36 #include "utilities/events.hpp"
37 #include "utilities/powerOfTwo.hpp"
38
39
40 ShenandoahNMethodTable* ShenandoahCodeRoots::_nmethod_table;
41 int ShenandoahCodeRoots::_disarmed_value = 1;
42
43 void ShenandoahCodeRoots::initialize() {
44 _nmethod_table = new ShenandoahNMethodTable();
45 }
46
47 void ShenandoahCodeRoots::register_nmethod(nmethod* nm) {
48 assert(CodeCache_lock->owned_by_self(), "Must have CodeCache_lock held");
49 _nmethod_table->register_nmethod(nm);
50 }
51
52 void ShenandoahCodeRoots::unregister_nmethod(nmethod* nm) {
53 assert_locked_or_safepoint(CodeCache_lock);
54 _nmethod_table->unregister_nmethod(nm);
55 }
56
57 void ShenandoahCodeRoots::arm_nmethods() {
58 char gc_state = ShenandoahHeap::heap()->gc_state();
59 Events::log(Thread::current(), "Arming nmethods, GC state: %d [%s%s%s%s%s%s%s]",
60 gc_state,
61 ((gc_state & ShenandoahHeap::HAS_FORWARDED) > 0) ? "HAS_FORWARDED " : "",
62 ((gc_state & ShenandoahHeap::MARKING) > 0) ? "MARKING " : "",
63 ((gc_state & ShenandoahHeap::EVACUATION) > 0) ? "EVACUATION " : "",
64 ((gc_state & ShenandoahHeap::UPDATE_REFS) > 0) ? "UPDATE_REFS " : "",
65 ((gc_state & ShenandoahHeap::WEAK_ROOTS) > 0) ? "WEAK_ROOTS " : "",
66 ((gc_state & ShenandoahHeap::YOUNG_MARKING) > 0) ? "YOUNG_MARKING " : "",
67 ((gc_state & ShenandoahHeap::OLD_MARKING) > 0) ? "OLD_MARKING " : ""
68 );
69 log_info(gc)("Arming nmethods with GC state: %d [%s%s%s%s%s%s%s]",
70 gc_state,
71 ((gc_state & ShenandoahHeap::HAS_FORWARDED) > 0) ? "HAS_FORWARDED " : "",
72 ((gc_state & ShenandoahHeap::MARKING) > 0) ? "MARKING " : "",
73 ((gc_state & ShenandoahHeap::EVACUATION) > 0) ? "EVACUATION " : "",
74 ((gc_state & ShenandoahHeap::UPDATE_REFS) > 0) ? "UPDATE_REFS " : "",
75 ((gc_state & ShenandoahHeap::WEAK_ROOTS) > 0) ? "WEAK_ROOTS " : "",
76 ((gc_state & ShenandoahHeap::YOUNG_MARKING) > 0) ? "YOUNG_MARKING " : "",
77 ((gc_state & ShenandoahHeap::OLD_MARKING) > 0) ? "OLD_MARKING " : ""
78 );
79 BarrierSet::barrier_set()->barrier_set_nmethod()->arm_all_nmethods();
80 }
81
82 class ShenandoahDisarmNMethodClosure : public NMethodClosure {
83 public:
84 virtual void do_nmethod(nmethod* nm) {
85 ShenandoahNMethod::disarm_nmethod(nm);
86 }
87 };
88
89 class ShenandoahDisarmNMethodsTask : public WorkerTask {
90 private:
91 ShenandoahDisarmNMethodClosure _cl;
92 ShenandoahConcurrentNMethodIterator _iterator;
93
94 public:
95 ShenandoahDisarmNMethodsTask() :
96 WorkerTask("Shenandoah Disarm NMethods"),
97 _iterator(ShenandoahCodeRoots::table()) {}
98
99 virtual void work(uint worker_id) {
100 _iterator.nmethods_do(&_cl);
101 }
102 };
103
104 void ShenandoahCodeRoots::disarm_nmethods() {
105 ShenandoahDisarmNMethodsTask task;
106 ShenandoahHeap::heap()->workers()->run_task(&task);
107 }
108
109 #ifdef ASSERT
110 class ShenandoahCheckNMethodClosure : public NMethodClosure {
111 bool const _armed;
112 public:
113 ShenandoahCheckNMethodClosure(int armed) : _armed(armed) {}
114 virtual void do_nmethod(nmethod* nm) {
115 ShenandoahNMethod::assert_barriers(nm, _armed);
116 }
117 };
118
119 class ShenandoahCheckNMethodsTask : public WorkerTask {
120 private:
121 ShenandoahCheckNMethodClosure _cl;
122 ShenandoahConcurrentNMethodIterator _iterator;
123
124 public:
125 ShenandoahCheckNMethodsTask() :
126 WorkerTask("Shenandoah Check NMethods"),
127 _cl(!ShenandoahHeap::heap()->is_idle()),
128 _iterator(ShenandoahCodeRoots::table()) {}
129
130 virtual void work(uint worker_id) {
131 _iterator.nmethods_do(&_cl);
132 }
133 };
134
135 void ShenandoahCodeRoots::check_barriers() {
136 ShenandoahCheckNMethodsTask task;
137 ShenandoahHeap::heap()->workers()->run_task(&task);
138 }
139 #endif
140
141 class ShenandoahNMethodUnlinkClosure : public NMethodClosure {
142 private:
143 bool _unloading_occurred;
144 ShenandoahHeap* const _heap;
145 BarrierSetNMethod* const _bs;
146
147 public:
148 ShenandoahNMethodUnlinkClosure(bool unloading_occurred) :
149 _unloading_occurred(unloading_occurred),
150 _heap(ShenandoahHeap::heap()),
151 _bs(ShenandoahBarrierSet::barrier_set()->barrier_set_nmethod()) {}
152
153 virtual void do_nmethod(nmethod* nm) {
154 assert(_heap->is_concurrent_weak_root_in_progress(), "Only this phase");
155
156 ShenandoahNMethod* nm_data = ShenandoahNMethod::gc_data(nm);
157 assert(!nm_data->is_unregistered(), "Should not see unregistered entry");
158
159 if (nm->is_unloading()) {
160 ShenandoahNMethodLocker locker(nm_data->lock());
|