--- a/src/hotspot/os/posix/os_posix.cpp Thu Oct 17 20:27:44 2019 +0100
+++ b/src/hotspot/os/posix/os_posix.cpp Thu Oct 17 20:53:35 2019 +0100
@@ -167,11 +167,6 @@
return n;
}
-bool os::is_debugger_attached() {
- // not implemented
- return false;
-}
-
void os::wait_for_keypress_at_exit(void) {
// don't do anything on posix platforms
return;
@@ -373,8 +368,12 @@
void os::Posix::print_load_average(outputStream* st) {
st->print("load average:");
double loadavg[3];
- os::loadavg(loadavg, 3);
- st->print("%0.02f %0.02f %0.02f", loadavg[0], loadavg[1], loadavg[2]);
+ int res = os::loadavg(loadavg, 3);
+ if (res != -1) {
+ st->print("%0.02f %0.02f %0.02f", loadavg[0], loadavg[1], loadavg[2]);
+ } else {
+ st->print(" Unavailable");
+ }
st->cr();
}
@@ -624,78 +623,6 @@
return agent_entry_name;
}
-int os::sleep(Thread* thread, jlong millis, bool interruptible) {
- assert(thread == Thread::current(), "thread consistency check");
-
- ParkEvent * const slp = thread->_SleepEvent ;
- slp->reset() ;
- OrderAccess::fence() ;
-
- if (interruptible) {
- jlong prevtime = javaTimeNanos();
-
- for (;;) {
- if (os::is_interrupted(thread, true)) {
- return OS_INTRPT;
- }
-
- jlong newtime = javaTimeNanos();
-
- if (newtime - prevtime < 0) {
- // time moving backwards, should only happen if no monotonic clock
- // not a guarantee() because JVM should not abort on kernel/glibc bugs
- assert(!os::supports_monotonic_clock(), "unexpected time moving backwards detected in os::sleep(interruptible)");
- } else {
- millis -= (newtime - prevtime) / NANOSECS_PER_MILLISEC;
- }
-
- if (millis <= 0) {
- return OS_OK;
- }
-
- prevtime = newtime;
-
- {
- assert(thread->is_Java_thread(), "sanity check");
- JavaThread *jt = (JavaThread *) thread;
- ThreadBlockInVM tbivm(jt);
- OSThreadWaitState osts(jt->osthread(), false /* not Object.wait() */);
-
- jt->set_suspend_equivalent();
- // cleared by handle_special_suspend_equivalent_condition() or
- // java_suspend_self() via check_and_wait_while_suspended()
-
- slp->park(millis);
-
- // were we externally suspended while we were waiting?
- jt->check_and_wait_while_suspended();
- }
- }
- } else {
- OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
- jlong prevtime = javaTimeNanos();
-
- for (;;) {
- // It'd be nice to avoid the back-to-back javaTimeNanos() calls on
- // the 1st iteration ...
- jlong newtime = javaTimeNanos();
-
- if (newtime - prevtime < 0) {
- // time moving backwards, should only happen if no monotonic clock
- // not a guarantee() because JVM should not abort on kernel/glibc bugs
- assert(!os::supports_monotonic_clock(), "unexpected time moving backwards detected on os::sleep(!interruptible)");
- } else {
- millis -= (newtime - prevtime) / NANOSECS_PER_MILLISEC;
- }
-
- if (millis <= 0) break ;
-
- prevtime = newtime;
- slp->park(millis);
- }
- return OS_OK ;
- }
-}
void os::naked_short_nanosleep(jlong ns) {
struct timespec req;
@@ -712,61 +639,6 @@
return;
}
-////////////////////////////////////////////////////////////////////////////////
-// interrupt support
-
-void os::interrupt(Thread* thread) {
- debug_only(Thread::check_for_dangling_thread_pointer(thread);)
-
- OSThread* osthread = thread->osthread();
-
- if (!osthread->interrupted()) {
- osthread->set_interrupted(true);
- // More than one thread can get here with the same value of osthread,
- // resulting in multiple notifications. We do, however, want the store
- // to interrupted() to be visible to other threads before we execute unpark().
- OrderAccess::fence();
- ParkEvent * const slp = thread->_SleepEvent ;
- if (slp != NULL) slp->unpark() ;
- }
-
- // For JSR166. Unpark even if interrupt status already was set
- if (thread->is_Java_thread())
- ((JavaThread*)thread)->parker()->unpark();
-
- ParkEvent * ev = thread->_ParkEvent ;
- if (ev != NULL) ev->unpark() ;
-}
-
-bool os::is_interrupted(Thread* thread, bool clear_interrupted) {
- debug_only(Thread::check_for_dangling_thread_pointer(thread);)
-
- OSThread* osthread = thread->osthread();
-
- bool interrupted = osthread->interrupted();
-
- // NOTE that since there is no "lock" around the interrupt and
- // is_interrupted operations, there is the possibility that the
- // interrupted flag (in osThread) will be "false" but that the
- // low-level events will be in the signaled state. This is
- // intentional. The effect of this is that Object.wait() and
- // LockSupport.park() will appear to have a spurious wakeup, which
- // is allowed and not harmful, and the possibility is so rare that
- // it is not worth the added complexity to add yet another lock.
- // For the sleep event an explicit reset is performed on entry
- // to os::sleep, so there is no early return. It has also been
- // recommended not to put the interrupted flag into the "event"
- // structure because it hides the issue.
- if (interrupted && clear_interrupted) {
- osthread->set_interrupted(false);
- // consider thread->_SleepEvent->reset() ... optional optimization
- }
-
- return interrupted;
-}
-
-
-
static const struct {
int sig; const char* name;
}
@@ -1450,6 +1322,30 @@
return path;
}
+bool os::same_files(const char* file1, const char* file2) {
+ if (strcmp(file1, file2) == 0) {
+ return true;
+ }
+
+ bool is_same = false;
+ struct stat st1;
+ struct stat st2;
+
+ if (os::stat(file1, &st1) < 0) {
+ return false;
+ }
+
+ if (os::stat(file2, &st2) < 0) {
+ return false;
+ }
+
+ if (st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino) {
+ // same files
+ is_same = true;
+ }
+ return is_same;
+}
+
// Check minimum allowable stack sizes for thread creation and to initialize
// the java system classes, including StackOverflowError - depends on page
// size.
@@ -1671,8 +1567,8 @@
if ((status = pthread_mutexattr_settype(_mutexAttr, PTHREAD_MUTEX_NORMAL)) != 0) {
fatal("pthread_mutexattr_settype: %s", os::strerror(status));
}
- // Solaris has it's own PlatformMonitor, distinct from the one for POSIX.
- NOT_SOLARIS(os::PlatformMonitor::init();)
+ // Solaris has it's own PlatformMutex, distinct from the one for POSIX.
+ NOT_SOLARIS(os::PlatformMutex::init();)
}
#ifndef SOLARIS
@@ -2097,7 +1993,7 @@
// shake out uses of park() and unpark() without checking state conditions
// properly. This spurious return doesn't manifest itself in any user code
// but only in the correctly written condition checking loops of ObjectMonitor,
- // Mutex/Monitor, Thread::muxAcquire and os::sleep
+ // Mutex/Monitor, Thread::muxAcquire and JavaThread::sleep
if (Atomic::xchg(1, &_event) >= 0) return;
@@ -2155,7 +2051,7 @@
// Optional optimization -- avoid state transitions if there's
// an interrupt pending.
- if (Thread::is_interrupted(thread, false)) {
+ if (jt->is_interrupted(false)) {
return;
}
@@ -2178,7 +2074,7 @@
// Don't wait if cannot get lock since interference arises from
// unparking. Also re-check interrupt before trying wait.
- if (Thread::is_interrupted(thread, false) ||
+ if (jt->is_interrupted(false) ||
pthread_mutex_trylock(_mutex) != 0) {
return;
}
@@ -2250,33 +2146,29 @@
}
}
-// Platform Monitor implementation
+// Platform Mutex/Monitor implementation
-os::PlatformMonitor::Impl::Impl() : _next(NULL) {
- int status = pthread_cond_init(&_cond, _condAttr);
- assert_status(status == 0, status, "cond_init");
- status = pthread_mutex_init(&_mutex, _mutexAttr);
+#if PLATFORM_MONITOR_IMPL_INDIRECT
+
+os::PlatformMutex::Mutex::Mutex() : _next(NULL) {
+ int status = pthread_mutex_init(&_mutex, _mutexAttr);
assert_status(status == 0, status, "mutex_init");
}
-os::PlatformMonitor::Impl::~Impl() {
- int status = pthread_cond_destroy(&_cond);
- assert_status(status == 0, status, "cond_destroy");
- status = pthread_mutex_destroy(&_mutex);
+os::PlatformMutex::Mutex::~Mutex() {
+ int status = pthread_mutex_destroy(&_mutex);
assert_status(status == 0, status, "mutex_destroy");
}
-#if PLATFORM_MONITOR_IMPL_INDIRECT
+pthread_mutex_t os::PlatformMutex::_freelist_lock;
+os::PlatformMutex::Mutex* os::PlatformMutex::_mutex_freelist = NULL;
-pthread_mutex_t os::PlatformMonitor::_freelist_lock;
-os::PlatformMonitor::Impl* os::PlatformMonitor::_freelist = NULL;
-
-void os::PlatformMonitor::init() {
+void os::PlatformMutex::init() {
int status = pthread_mutex_init(&_freelist_lock, _mutexAttr);
assert_status(status == 0, status, "freelist lock init");
}
-struct os::PlatformMonitor::WithFreeListLocked : public StackObj {
+struct os::PlatformMutex::WithFreeListLocked : public StackObj {
WithFreeListLocked() {
int status = pthread_mutex_lock(&_freelist_lock);
assert_status(status == 0, status, "freelist lock");
@@ -2288,24 +2180,78 @@
}
};
-os::PlatformMonitor::PlatformMonitor() {
+os::PlatformMutex::PlatformMutex() {
{
WithFreeListLocked wfl;
- _impl = _freelist;
+ _impl = _mutex_freelist;
if (_impl != NULL) {
- _freelist = _impl->_next;
+ _mutex_freelist = _impl->_next;
_impl->_next = NULL;
return;
}
}
- _impl = new Impl();
+ _impl = new Mutex();
+}
+
+os::PlatformMutex::~PlatformMutex() {
+ WithFreeListLocked wfl;
+ assert(_impl->_next == NULL, "invariant");
+ _impl->_next = _mutex_freelist;
+ _mutex_freelist = _impl;
+}
+
+os::PlatformMonitor::Cond::Cond() : _next(NULL) {
+ int status = pthread_cond_init(&_cond, _condAttr);
+ assert_status(status == 0, status, "cond_init");
+}
+
+os::PlatformMonitor::Cond::~Cond() {
+ int status = pthread_cond_destroy(&_cond);
+ assert_status(status == 0, status, "cond_destroy");
+}
+
+os::PlatformMonitor::Cond* os::PlatformMonitor::_cond_freelist = NULL;
+
+os::PlatformMonitor::PlatformMonitor() {
+ {
+ WithFreeListLocked wfl;
+ _impl = _cond_freelist;
+ if (_impl != NULL) {
+ _cond_freelist = _impl->_next;
+ _impl->_next = NULL;
+ return;
+ }
+ }
+ _impl = new Cond();
}
os::PlatformMonitor::~PlatformMonitor() {
WithFreeListLocked wfl;
assert(_impl->_next == NULL, "invariant");
- _impl->_next = _freelist;
- _freelist = _impl;
+ _impl->_next = _cond_freelist;
+ _cond_freelist = _impl;
+}
+
+#else
+
+os::PlatformMutex::PlatformMutex() {
+ int status = pthread_mutex_init(&_mutex, _mutexAttr);
+ assert_status(status == 0, status, "mutex_init");
+}
+
+os::PlatformMutex::~PlatformMutex() {
+ int status = pthread_mutex_destroy(&_mutex);
+ assert_status(status == 0, status, "mutex_destroy");
+}
+
+os::PlatformMonitor::PlatformMonitor() {
+ int status = pthread_cond_init(&_cond, _condAttr);
+ assert_status(status == 0, status, "cond_init");
+}
+
+os::PlatformMonitor::~PlatformMonitor() {
+ int status = pthread_cond_destroy(&_cond);
+ assert_status(status == 0, status, "cond_destroy");
}
#endif // PLATFORM_MONITOR_IMPL_INDIRECT