247 ParkEvent * ev = NULL ; // consider using a small auto array ...
248 RawMonitor_lock->lock_without_safepoint_check() ;
249 for (;;) {
250 ObjectWaiter * w = _WaitSet ;
251 if (w == NULL) break ;
252 _WaitSet = w->_next ;
253 if (ev != NULL) { ev->unpark(); ev = NULL; }
254 ev = w->_event ;
255 OrderAccess::loadstore() ;
256 w->TState = ObjectWaiter::TS_RUN ;
257 OrderAccess::storeload();
258 if (!All) break ;
259 }
260 RawMonitor_lock->unlock() ;
261 if (ev != NULL) ev->unpark();
262 return OS_OK ;
263 }
264
265 // Any JavaThread will enter here with state _thread_blocked
266 int JvmtiRawMonitor::raw_enter(TRAPS) {
267 TEVENT (raw_enter) ;
268 void * Contended ;
269
270 // don't enter raw monitor if thread is being externally suspended, it will
271 // surprise the suspender if a "suspended" thread can still enter monitor
272 JavaThread * jt = (JavaThread *)THREAD;
273 if (THREAD->is_Java_thread()) {
274 jt->SR_lock()->lock_without_safepoint_check();
275 while (jt->is_external_suspend()) {
276 jt->SR_lock()->unlock();
277 jt->java_suspend_self();
278 jt->SR_lock()->lock_without_safepoint_check();
279 }
280 // guarded by SR_lock to avoid racing with new external suspend requests.
281 Contended = Atomic::cmpxchg(THREAD, &_owner, (void*)NULL);
282 jt->SR_lock()->unlock();
283 } else {
284 Contended = Atomic::cmpxchg(THREAD, &_owner, (void*)NULL);
285 }
286
287 if (Contended == THREAD) {
324 // thread that suspended us.
325 //
326 // Drop the lock -
327 SimpleExit (THREAD) ;
328
329 jt->java_suspend_self();
330 }
331
332 assert(_owner == THREAD, "Fatal error with monitor owner!");
333 assert(_recursions == 0, "Fatal error with monitor recursions!");
334 }
335
336 THREAD->set_current_pending_monitor(NULL);
337 guarantee (_recursions == 0, "invariant") ;
338 return OM_OK;
339 }
340
341 // Used mainly for JVMTI raw monitor implementation
342 // Also used for JvmtiRawMonitor::wait().
343 int JvmtiRawMonitor::raw_exit(TRAPS) {
344 TEVENT (raw_exit) ;
345 if (THREAD != _owner) {
346 return OM_ILLEGAL_MONITOR_STATE;
347 }
348 if (_recursions > 0) {
349 --_recursions ;
350 return OM_OK ;
351 }
352
353 void * List = _EntryList ;
354 SimpleExit (THREAD) ;
355
356 return OM_OK;
357 }
358
359 // Used for JVMTI raw monitor implementation.
360 // All JavaThreads will enter here with state _thread_blocked
361
362 int JvmtiRawMonitor::raw_wait(jlong millis, bool interruptible, TRAPS) {
363 TEVENT (raw_wait) ;
364 if (THREAD != _owner) {
365 return OM_ILLEGAL_MONITOR_STATE;
366 }
367
368 // To avoid spurious wakeups we reset the parkevent -- This is strictly optional.
369 // The caller must be able to tolerate spurious returns from raw_wait().
370 THREAD->_ParkEvent->reset() ;
371 OrderAccess::fence() ;
372
373 // check interrupt event
374 if (interruptible && Thread::is_interrupted(THREAD, true)) {
375 return OM_INTERRUPTED;
376 }
377
378 intptr_t save = _recursions ;
379 _recursions = 0 ;
380 _waiters ++ ;
381 if (THREAD->is_Java_thread()) {
382 guarantee (((JavaThread *) THREAD)->thread_state() == _thread_blocked, "invariant") ;
383 ((JavaThread *)THREAD)->set_suspend_equivalent();
389 guarantee (THREAD == _owner, "invariant") ;
390 if (THREAD->is_Java_thread()) {
391 JavaThread * jSelf = (JavaThread *) THREAD ;
392 for (;;) {
393 if (!jSelf->handle_special_suspend_equivalent_condition()) break ;
394 SimpleExit (THREAD) ;
395 jSelf->java_suspend_self();
396 SimpleEnter (THREAD) ;
397 jSelf->set_suspend_equivalent() ;
398 }
399 }
400 guarantee (THREAD == _owner, "invariant") ;
401
402 if (interruptible && Thread::is_interrupted(THREAD, true)) {
403 return OM_INTERRUPTED;
404 }
405 return OM_OK ;
406 }
407
408 int JvmtiRawMonitor::raw_notify(TRAPS) {
409 TEVENT (raw_notify) ;
410 if (THREAD != _owner) {
411 return OM_ILLEGAL_MONITOR_STATE;
412 }
413 SimpleNotify (THREAD, false) ;
414 return OM_OK;
415 }
416
417 int JvmtiRawMonitor::raw_notifyAll(TRAPS) {
418 TEVENT (raw_notifyAll) ;
419 if (THREAD != _owner) {
420 return OM_ILLEGAL_MONITOR_STATE;
421 }
422 SimpleNotify (THREAD, true) ;
423 return OM_OK;
424 }
|
247 ParkEvent * ev = NULL ; // consider using a small auto array ...
248 RawMonitor_lock->lock_without_safepoint_check() ;
249 for (;;) {
250 ObjectWaiter * w = _WaitSet ;
251 if (w == NULL) break ;
252 _WaitSet = w->_next ;
253 if (ev != NULL) { ev->unpark(); ev = NULL; }
254 ev = w->_event ;
255 OrderAccess::loadstore() ;
256 w->TState = ObjectWaiter::TS_RUN ;
257 OrderAccess::storeload();
258 if (!All) break ;
259 }
260 RawMonitor_lock->unlock() ;
261 if (ev != NULL) ev->unpark();
262 return OS_OK ;
263 }
264
265 // Any JavaThread will enter here with state _thread_blocked
266 int JvmtiRawMonitor::raw_enter(TRAPS) {
267 void * Contended ;
268
269 // don't enter raw monitor if thread is being externally suspended, it will
270 // surprise the suspender if a "suspended" thread can still enter monitor
271 JavaThread * jt = (JavaThread *)THREAD;
272 if (THREAD->is_Java_thread()) {
273 jt->SR_lock()->lock_without_safepoint_check();
274 while (jt->is_external_suspend()) {
275 jt->SR_lock()->unlock();
276 jt->java_suspend_self();
277 jt->SR_lock()->lock_without_safepoint_check();
278 }
279 // guarded by SR_lock to avoid racing with new external suspend requests.
280 Contended = Atomic::cmpxchg(THREAD, &_owner, (void*)NULL);
281 jt->SR_lock()->unlock();
282 } else {
283 Contended = Atomic::cmpxchg(THREAD, &_owner, (void*)NULL);
284 }
285
286 if (Contended == THREAD) {
323 // thread that suspended us.
324 //
325 // Drop the lock -
326 SimpleExit (THREAD) ;
327
328 jt->java_suspend_self();
329 }
330
331 assert(_owner == THREAD, "Fatal error with monitor owner!");
332 assert(_recursions == 0, "Fatal error with monitor recursions!");
333 }
334
335 THREAD->set_current_pending_monitor(NULL);
336 guarantee (_recursions == 0, "invariant") ;
337 return OM_OK;
338 }
339
340 // Used mainly for JVMTI raw monitor implementation
341 // Also used for JvmtiRawMonitor::wait().
342 int JvmtiRawMonitor::raw_exit(TRAPS) {
343 if (THREAD != _owner) {
344 return OM_ILLEGAL_MONITOR_STATE;
345 }
346 if (_recursions > 0) {
347 --_recursions ;
348 return OM_OK ;
349 }
350
351 void * List = _EntryList ;
352 SimpleExit (THREAD) ;
353
354 return OM_OK;
355 }
356
357 // Used for JVMTI raw monitor implementation.
358 // All JavaThreads will enter here with state _thread_blocked
359
360 int JvmtiRawMonitor::raw_wait(jlong millis, bool interruptible, TRAPS) {
361 if (THREAD != _owner) {
362 return OM_ILLEGAL_MONITOR_STATE;
363 }
364
365 // To avoid spurious wakeups we reset the parkevent -- This is strictly optional.
366 // The caller must be able to tolerate spurious returns from raw_wait().
367 THREAD->_ParkEvent->reset() ;
368 OrderAccess::fence() ;
369
370 // check interrupt event
371 if (interruptible && Thread::is_interrupted(THREAD, true)) {
372 return OM_INTERRUPTED;
373 }
374
375 intptr_t save = _recursions ;
376 _recursions = 0 ;
377 _waiters ++ ;
378 if (THREAD->is_Java_thread()) {
379 guarantee (((JavaThread *) THREAD)->thread_state() == _thread_blocked, "invariant") ;
380 ((JavaThread *)THREAD)->set_suspend_equivalent();
386 guarantee (THREAD == _owner, "invariant") ;
387 if (THREAD->is_Java_thread()) {
388 JavaThread * jSelf = (JavaThread *) THREAD ;
389 for (;;) {
390 if (!jSelf->handle_special_suspend_equivalent_condition()) break ;
391 SimpleExit (THREAD) ;
392 jSelf->java_suspend_self();
393 SimpleEnter (THREAD) ;
394 jSelf->set_suspend_equivalent() ;
395 }
396 }
397 guarantee (THREAD == _owner, "invariant") ;
398
399 if (interruptible && Thread::is_interrupted(THREAD, true)) {
400 return OM_INTERRUPTED;
401 }
402 return OM_OK ;
403 }
404
405 int JvmtiRawMonitor::raw_notify(TRAPS) {
406 if (THREAD != _owner) {
407 return OM_ILLEGAL_MONITOR_STATE;
408 }
409 SimpleNotify (THREAD, false) ;
410 return OM_OK;
411 }
412
413 int JvmtiRawMonitor::raw_notifyAll(TRAPS) {
414 if (THREAD != _owner) {
415 return OM_ILLEGAL_MONITOR_STATE;
416 }
417 SimpleNotify (THREAD, true) ;
418 return OM_OK;
419 }
|