Mercurial > hg > truffle
comparison src/os/solaris/vm/osThread_solaris.cpp @ 10405:f2110083203d
8005849: JEP 167: Event-Based JVM Tracing
Reviewed-by: acorn, coleenp, sla
Contributed-by: Karen Kinnear <karen.kinnear@oracle.com>, Bengt Rutisson <bengt.rutisson@oracle.com>, Calvin Cheung <calvin.cheung@oracle.com>, Erik Gahlin <erik.gahlin@oracle.com>, Erik Helin <erik.helin@oracle.com>, Jesper Wilhelmsson <jesper.wilhelmsson@oracle.com>, Keith McGuigan <keith.mcguigan@oracle.com>, Mattias Tobiasson <mattias.tobiasson@oracle.com>, Markus Gronlund <markus.gronlund@oracle.com>, Mikael Auno <mikael.auno@oracle.com>, Nils Eliasson <nils.eliasson@oracle.com>, Nils Loodin <nils.loodin@oracle.com>, Rickard Backman <rickard.backman@oracle.com>, Staffan Larsen <staffan.larsen@oracle.com>, Stefan Karlsson <stefan.karlsson@oracle.com>, Yekaterina Kantserova <yekaterina.kantserova@oracle.com>
author | sla |
---|---|
date | Mon, 10 Jun 2013 11:30:51 +0200 |
parents | cd3d6a6b95d9 |
children |
comparison
equal
deleted
inserted
replaced
10404:d0add7016434 | 10405:f2110083203d |
---|---|
1 /* | 1 /* |
2 * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved. | 2 * Copyright (c) 1998, 2013, Oracle and/or its affiliates. All rights reserved. |
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 * | 4 * |
5 * This code is free software; you can redistribute it and/or modify it | 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 | 6 * under the terms of the GNU General Public License version 2 only, as |
7 * published by the Free Software Foundation. | 7 * published by the Free Software Foundation. |
39 | 39 |
40 void OSThread::pd_initialize() { | 40 void OSThread::pd_initialize() { |
41 _thread_id = 0; | 41 _thread_id = 0; |
42 sigemptyset(&_caller_sigmask); | 42 sigemptyset(&_caller_sigmask); |
43 | 43 |
44 _current_callback = NULL; | |
45 _current_callback_lock = VM_Version::supports_compare_and_exchange() ? NULL | |
46 : new Mutex(Mutex::suspend_resume, "Callback_lock", true); | |
47 | |
48 _saved_interrupt_thread_state = _thread_new; | 44 _saved_interrupt_thread_state = _thread_new; |
49 _vm_created_thread = false; | 45 _vm_created_thread = false; |
50 } | 46 } |
51 | 47 |
52 void OSThread::pd_destroy() { | 48 void OSThread::pd_destroy() { |
53 } | |
54 | |
55 // Synchronous interrupt support | |
56 // | |
57 // _current_callback == NULL no pending callback | |
58 // == 1 callback_in_progress | |
59 // == other value pointer to the pending callback | |
60 // | |
61 | |
62 // CAS on v8 is implemented by using a global atomic_memory_operation_lock, | |
63 // which is shared by other atomic functions. It is OK for normal uses, but | |
64 // dangerous if used after some thread is suspended or if used in signal | |
65 // handlers. Instead here we use a special per-thread lock to synchronize | |
66 // updating _current_callback if we are running on v8. Note in general trying | |
67 // to grab locks after a thread is suspended is not safe, but it is safe for | |
68 // updating _current_callback, because synchronous interrupt callbacks are | |
69 // currently only used in: | |
70 // 1. GetThreadPC_Callback - used by WatcherThread to profile VM thread | |
71 // There is no overlap between the callbacks, which means we won't try to | |
72 // grab a thread's sync lock after the thread has been suspended while holding | |
73 // the same lock. | |
74 | |
75 // used after a thread is suspended | |
76 static intptr_t compare_and_exchange_current_callback ( | |
77 intptr_t callback, intptr_t *addr, intptr_t compare_value, Mutex *sync) { | |
78 if (VM_Version::supports_compare_and_exchange()) { | |
79 return Atomic::cmpxchg_ptr(callback, addr, compare_value); | |
80 } else { | |
81 MutexLockerEx ml(sync, Mutex::_no_safepoint_check_flag); | |
82 if (*addr == compare_value) { | |
83 *addr = callback; | |
84 return compare_value; | |
85 } else { | |
86 return callback; | |
87 } | |
88 } | |
89 } | |
90 | |
91 // used in signal handler | |
92 static intptr_t exchange_current_callback(intptr_t callback, intptr_t *addr, Mutex *sync) { | |
93 if (VM_Version::supports_compare_and_exchange()) { | |
94 return Atomic::xchg_ptr(callback, addr); | |
95 } else { | |
96 MutexLockerEx ml(sync, Mutex::_no_safepoint_check_flag); | |
97 intptr_t cb = *addr; | |
98 *addr = callback; | |
99 return cb; | |
100 } | |
101 } | |
102 | |
103 // one interrupt at a time. spin if _current_callback != NULL | |
104 int OSThread::set_interrupt_callback(Sync_Interrupt_Callback * cb) { | |
105 int count = 0; | |
106 while (compare_and_exchange_current_callback( | |
107 (intptr_t)cb, (intptr_t *)&_current_callback, (intptr_t)NULL, _current_callback_lock) != NULL) { | |
108 while (_current_callback != NULL) { | |
109 count++; | |
110 #ifdef ASSERT | |
111 if ((WarnOnStalledSpinLock > 0) && | |
112 (count % WarnOnStalledSpinLock == 0)) { | |
113 warning("_current_callback seems to be stalled: %p", _current_callback); | |
114 } | |
115 #endif | |
116 os::yield_all(count); | |
117 } | |
118 } | |
119 return 0; | |
120 } | |
121 | |
122 // reset _current_callback, spin if _current_callback is callback_in_progress | |
123 void OSThread::remove_interrupt_callback(Sync_Interrupt_Callback * cb) { | |
124 int count = 0; | |
125 while (compare_and_exchange_current_callback( | |
126 (intptr_t)NULL, (intptr_t *)&_current_callback, (intptr_t)cb, _current_callback_lock) != (intptr_t)cb) { | |
127 #ifdef ASSERT | |
128 intptr_t p = (intptr_t)_current_callback; | |
129 assert(p == (intptr_t)callback_in_progress || | |
130 p == (intptr_t)cb, "wrong _current_callback value"); | |
131 #endif | |
132 while (_current_callback != cb) { | |
133 count++; | |
134 #ifdef ASSERT | |
135 if ((WarnOnStalledSpinLock > 0) && | |
136 (count % WarnOnStalledSpinLock == 0)) { | |
137 warning("_current_callback seems to be stalled: %p", _current_callback); | |
138 } | |
139 #endif | |
140 os::yield_all(count); | |
141 } | |
142 } | |
143 } | |
144 | |
145 void OSThread::do_interrupt_callbacks_at_interrupt(InterruptArguments *args) { | |
146 Sync_Interrupt_Callback * cb; | |
147 cb = (Sync_Interrupt_Callback *)exchange_current_callback( | |
148 (intptr_t)callback_in_progress, (intptr_t *)&_current_callback, _current_callback_lock); | |
149 | |
150 if (cb == NULL) { | |
151 // signal is delivered too late (thread is masking interrupt signal??). | |
152 // there is nothing we need to do because requesting thread has given up. | |
153 } else if ((intptr_t)cb == (intptr_t)callback_in_progress) { | |
154 fatal("invalid _current_callback state"); | |
155 } else { | |
156 assert(cb->target()->osthread() == this, "wrong target"); | |
157 cb->execute(args); | |
158 cb->leave_callback(); // notify the requester | |
159 } | |
160 | |
161 // restore original _current_callback value | |
162 intptr_t p; | |
163 p = exchange_current_callback((intptr_t)cb, (intptr_t *)&_current_callback, _current_callback_lock); | |
164 assert(p == (intptr_t)callback_in_progress, "just checking"); | |
165 } | |
166 | |
167 // Called by the requesting thread to send a signal to target thread and | |
168 // execute "this" callback from the signal handler. | |
169 int OSThread::Sync_Interrupt_Callback::interrupt(Thread * target, int timeout) { | |
170 // Let signals to the vm_thread go even if the Threads_lock is not acquired | |
171 assert(Threads_lock->owned_by_self() || (target == VMThread::vm_thread()), | |
172 "must have threads lock to call this"); | |
173 | |
174 OSThread * osthread = target->osthread(); | |
175 | |
176 // may block if target thread already has a pending callback | |
177 osthread->set_interrupt_callback(this); | |
178 | |
179 _target = target; | |
180 | |
181 int rslt = thr_kill(osthread->thread_id(), os::Solaris::SIGasync()); | |
182 assert(rslt == 0, "thr_kill != 0"); | |
183 | |
184 bool status = false; | |
185 jlong t1 = os::javaTimeMillis(); | |
186 { // don't use safepoint check because we might be the watcher thread. | |
187 MutexLockerEx ml(_sync, Mutex::_no_safepoint_check_flag); | |
188 while (!is_done()) { | |
189 status = _sync->wait(Mutex::_no_safepoint_check_flag, timeout); | |
190 | |
191 // status == true if timed out | |
192 if (status) break; | |
193 | |
194 // update timeout | |
195 jlong t2 = os::javaTimeMillis(); | |
196 timeout -= t2 - t1; | |
197 t1 = t2; | |
198 } | |
199 } | |
200 | |
201 // reset current_callback | |
202 osthread->remove_interrupt_callback(this); | |
203 | |
204 return status; | |
205 } | |
206 | |
207 void OSThread::Sync_Interrupt_Callback::leave_callback() { | |
208 if (!_sync->owned_by_self()) { | |
209 // notify requesting thread | |
210 MutexLockerEx ml(_sync, Mutex::_no_safepoint_check_flag); | |
211 _is_done = true; | |
212 _sync->notify_all(); | |
213 } else { | |
214 // Current thread is interrupted while it is holding the _sync lock, trying | |
215 // to grab it again will deadlock. The requester will timeout anyway, | |
216 // so just return. | |
217 _is_done = true; | |
218 } | |
219 } | 49 } |
220 | 50 |
221 // copied from synchronizer.cpp | 51 // copied from synchronizer.cpp |
222 | 52 |
223 void OSThread::handle_spinlock_contention(int tries) { | 53 void OSThread::handle_spinlock_contention(int tries) { |
227 os::yield_all(tries); // Yield to threads of any priority | 57 os::yield_all(tries); // Yield to threads of any priority |
228 } else if (tries > 5) { | 58 } else if (tries > 5) { |
229 os::yield(); // Yield to threads of same or higher priority | 59 os::yield(); // Yield to threads of same or higher priority |
230 } | 60 } |
231 } | 61 } |
62 | |
63 void OSThread::SR_handler(Thread* thread, ucontext_t* uc) { | |
64 os::Solaris::SR_handler(thread, uc); | |
65 } |