jdk-sandbox: comparison hotspot/src/share/vm/runtime/thread.cpp

equal deleted inserted replaced

-:655c5b5f7486
+:bd0d881cf1c5
 // The watcher thread exists to simulate timer interrupts.  It should
 // be replaced by an abstraction over whatever native support for
 // timer interrupts exists on the platform.
 WatcherThread* WatcherThread::_watcher_thread   = NULL;
+bool WatcherThread::_startable = false;
 volatile bool  WatcherThread::_should_terminate = false;
 WatcherThread::WatcherThread() : Thread() {
 assert(watcher_thread() == NULL, "we can only allocate one WatcherThread");
 if (os::create_thread(this, os::watcher_thread)) {
 os::start_thread(this);
 }
 }
 }
+int WatcherThread::sleep() const {
+MutexLockerEx ml(PeriodicTask_lock, Mutex::_no_safepoint_check_flag);
+// remaining will be zero if there are no tasks,
+// causing the WatcherThread to sleep until a task is
+// enrolled
+int remaining = PeriodicTask::time_to_wait();
+int time_slept = 0;
+// we expect this to timeout - we only ever get unparked when
+// we should terminate or when a new task has been enrolled
+OSThreadWaitState osts(this->osthread(), false /* not Object.wait() */);
+jlong time_before_loop = os::javaTimeNanos();
+for (;;) {
+bool timedout = PeriodicTask_lock->wait(Mutex::_no_safepoint_check_flag, remaining);
+jlong now = os::javaTimeNanos();
+if (remaining == 0) {
+// if we didn't have any tasks we could have waited for a long time
+// consider the time_slept zero and reset time_before_loop
+time_slept = 0;
+time_before_loop = now;
+} else {
+// need to recalulate since we might have new tasks in _tasks
+time_slept = (int) ((now - time_before_loop) / 1000000);
+}
+// Change to task list or spurious wakeup of some kind
+if (timedout || _should_terminate) {
+break;
+}
+remaining = PeriodicTask::time_to_wait();
+if (remaining == 0) {
+// Last task was just disenrolled so loop around and wait until
+// another task gets enrolled
+continue;
+}
+remaining -= time_slept;
+if (remaining <= 0)
+break;
+}
+return time_slept;
+}
 void WatcherThread::run() {
 assert(this == watcher_thread(), "just checking");
 this->record_stack_base_and_size();
 this->initialize_thread_local_storage();
 assert(watcher_thread() == Thread::current(),  "thread consistency check");
 assert(watcher_thread() == this,  "thread consistency check");
 // Calculate how long it'll be until the next PeriodicTask work
 // should be done, and sleep that amount of time.
-size_t time_to_wait = PeriodicTask::time_to_wait();
+int time_waited = sleep();
-// we expect this to timeout - we only ever get unparked when
-// we should terminate
-{
-OSThreadWaitState osts(this->osthread(), false /* not Object.wait() */);
-jlong prev_time = os::javaTimeNanos();
-for (;;) {
-int res= _SleepEvent->park(time_to_wait);
-if (res == OS_TIMEOUT || _should_terminate)
-break;
-// spurious wakeup of some kind
-jlong now = os::javaTimeNanos();
-time_to_wait -= (now - prev_time) / 1000000;
-if (time_to_wait <= 0)
-break;
-prev_time = now;
-}
-}
 if (is_error_reported()) {
 // A fatal error has happened, the error handler(VMError::report_and_die)
 // should abort JVM after creating an error log file. However in some
 // rare cases, the error handler itself might deadlock. Here we try to
 // ShowMessageBoxOnError when it is ready to abort.
 os::sleep(this, 5 * 1000, false);
 }
 }
-PeriodicTask::real_time_tick(time_to_wait);
+PeriodicTask::real_time_tick(time_waited);
-// If we have no more tasks left due to dynamic disenrollment,
-// shut down the thread since we don't currently support dynamic enrollment
-if (PeriodicTask::num_tasks() == 0) {
-_should_terminate = true;
-}
 }
 // Signal that it is terminated
 {
 MutexLockerEx mu(Terminator_lock, Mutex::_no_safepoint_check_flag);
 // Thread destructor usually does this..
 ThreadLocalStorage::set_thread(NULL);
 }
 void WatcherThread::start() {
-if (watcher_thread() == NULL) {
+assert(PeriodicTask_lock->owned_by_self(), "PeriodicTask_lock required");
+if (watcher_thread() == NULL && _startable) {
 _should_terminate = false;
 // Create the single instance of WatcherThread
 new WatcherThread();
 }
 }
+void WatcherThread::make_startable() {
+assert(PeriodicTask_lock->owned_by_self(), "PeriodicTask_lock required");
+_startable = true;
+}
 void WatcherThread::stop() {
+{
+MutexLockerEx ml(PeriodicTask_lock, Mutex::_no_safepoint_check_flag);
+_should_terminate = true;
+OrderAccess::fence();  // ensure WatcherThread sees update in main loop
+WatcherThread* watcher = watcher_thread();
+if (watcher != NULL)
+watcher->unpark();
+}
 // it is ok to take late safepoints here, if needed
 MutexLocker mu(Terminator_lock);
-_should_terminate = true;
-OrderAccess::fence();  // ensure WatcherThread sees update in main loop
-Thread* watcher = watcher_thread();
-if (watcher != NULL)
-watcher->_SleepEvent->unpark();
 while(watcher_thread() != NULL) {
 // This wait should make safepoint checks, wait without a timeout,
 // and wait as a suspend-equivalent condition.
 //
 // suspend-equivalent condition solves that timeout problem.
 //
 Terminator_lock->wait(!Mutex::_no_safepoint_check_flag, 0,
 Mutex::_as_suspend_equivalent_flag);
 }
+}
+void WatcherThread::unpark() {
+MutexLockerEx ml(PeriodicTask_lock->owned_by_self() ? NULL : PeriodicTask_lock, Mutex::_no_safepoint_check_flag);
+PeriodicTask_lock->notify();
 }
 void WatcherThread::print_on(outputStream* st) const {
 st->print("\"%s\" ", name());
 Thread::print_on(st);
 if (HAS_PENDING_EXCEPTION) {
 CLEAR_PENDING_EXCEPTION;
 }
 }
-// Start up the WatcherThread if there are any periodic tasks
+{
-// NOTE:  All PeriodicTasks should be registered by now. If they
+MutexLockerEx ml(PeriodicTask_lock, Mutex::_no_safepoint_check_flag);
-//   aren't, late joiners might appear to start slowly (we might
+// Make sure the watcher thread can be started by WatcherThread::start()
-//   take a while to process their first tick).
+// or by dynamic enrollment.
-if (PeriodicTask::num_tasks() > 0) {
+WatcherThread::make_startable();
-WatcherThread::start();
+// Start up the WatcherThread if there are any periodic tasks
+// NOTE:  All PeriodicTasks should be registered by now. If they
+//   aren't, late joiners might appear to start slowly (we might
+//   take a while to process their first tick).
+if (PeriodicTask::num_tasks() > 0) {
+WatcherThread::start();
+}
 }
 // Give os specific code one last chance to start
 os::init_3();

changeset 14390	bd0d881cf1c5
parent 14289	aec758622b4b
child 14488	ab48109f7d1b
child 14472	31ed75482688