Mercurial > hg > graal-compiler

comparison src/os/solaris/vm/osThread_solaris.cpp @ 10405:f2110083203d

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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 }