Mercurial > hg > truffle
changeset 14513:16c705d792be
Merge
| author | morris |
|---|---|
| date | Fri, 28 Feb 2014 08:02:20 -0800 |
| parents | 7d30d4f37d31 (diff) 484a359ff649 (current diff) |
| children | 2328dac1da27 |
| files | src/share/vm/oops/instanceKlass.cpp src/share/vm/opto/graphKit.cpp src/share/vm/runtime/arguments.cpp src/share/vm/runtime/frame.cpp src/share/vm/runtime/frame.hpp |
| diffstat | 64 files changed, 575 insertions(+), 761 deletions(-) [+] |
line wrap: on
line diff
--- a/make/excludeSrc.make Fri Feb 28 13:44:16 2014 +0100 +++ b/make/excludeSrc.make Fri Feb 28 08:02:20 2014 -0800 @@ -86,7 +86,7 @@ concurrentMark.cpp concurrentMarkThread.cpp dirtyCardQueue.cpp g1AllocRegion.cpp \ g1BlockOffsetTable.cpp g1CardCounts.cpp g1CollectedHeap.cpp g1CollectorPolicy.cpp \ g1ErgoVerbose.cpp g1GCPhaseTimes.cpp g1HRPrinter.cpp g1HotCardCache.cpp g1Log.cpp \ - g1MMUTracker.cpp g1MarkSweep.cpp g1MemoryPool.cpp g1MonitoringSupport.cpp \ + g1MMUTracker.cpp g1MarkSweep.cpp g1MemoryPool.cpp g1MonitoringSupport.cpp g1OopClosures.cpp \ g1RemSet.cpp g1RemSetSummary.cpp g1SATBCardTableModRefBS.cpp g1_globals.cpp heapRegion.cpp \ g1BiasedArray.cpp heapRegionRemSet.cpp heapRegionSeq.cpp heapRegionSet.cpp heapRegionSets.cpp \ ptrQueue.cpp satbQueue.cpp sparsePRT.cpp survRateGroup.cpp vm_operations_g1.cpp \
--- a/make/windows/makefiles/projectcreator.make Fri Feb 28 13:44:16 2014 +0100 +++ b/make/windows/makefiles/projectcreator.make Fri Feb 28 08:02:20 2014 -0800 @@ -72,6 +72,7 @@ -ignorePath arm \ -ignorePath ppc \ -ignorePath zero \ + -ignorePath aix \ -hidePath .hg
--- a/src/os/bsd/vm/os_bsd.cpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/os/bsd/vm/os_bsd.cpp Fri Feb 28 08:02:20 2014 -0800 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -994,7 +994,7 @@ jlong os::javaTimeNanos() { - if (Bsd::supports_monotonic_clock()) { + if (os::supports_monotonic_clock()) { struct timespec tp; int status = Bsd::clock_gettime(CLOCK_MONOTONIC, &tp); assert(status == 0, "gettime error"); @@ -1010,7 +1010,7 @@ } void os::javaTimeNanos_info(jvmtiTimerInfo *info_ptr) { - if (Bsd::supports_monotonic_clock()) { + if (os::supports_monotonic_clock()) { info_ptr->max_value = ALL_64_BITS; // CLOCK_MONOTONIC - amount of time since some arbitrary point in the past @@ -2513,85 +2513,6 @@ RESTARTABLE_RETURN_INT(::read(fd, buf, nBytes)); } -// TODO-FIXME: reconcile Solaris' os::sleep with the bsd variation. -// Solaris uses poll(), bsd uses park(). -// Poll() is likely a better choice, assuming that Thread.interrupt() -// generates a SIGUSRx signal. Note that SIGUSR1 can interfere with -// SIGSEGV, see 4355769. - -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(!Bsd::supports_monotonic_clock(), "time moving backwards"); - } 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(!Bsd::supports_monotonic_clock(), "time moving backwards"); - } else { - millis -= (newtime - prevtime) / NANOSECS_PER_MILLISEC; - } - - if(millis <= 0) break ; - - prevtime = newtime; - slp->park(millis); - } - return OS_OK ; - } -} - void os::naked_short_sleep(jlong ms) { struct timespec req; @@ -2987,50 +2908,6 @@ guarantee(osthread->sr.is_running(), "Must be running!"); } -//////////////////////////////////////////////////////////////////////////////// -// interrupt support - -void os::interrupt(Thread* thread) { - assert(Thread::current() == thread || Threads_lock->owned_by_self(), - "possibility of dangling Thread pointer"); - - 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) { - assert(Thread::current() == thread || Threads_lock->owned_by_self(), - "possibility of dangling Thread pointer"); - - OSThread* osthread = thread->osthread(); - - bool interrupted = osthread->interrupted(); - - if (interrupted && clear_interrupted) { - osthread->set_interrupted(false); - // consider thread->_SleepEvent->reset() ... optional optimization - } - - return interrupted; -} - /////////////////////////////////////////////////////////////////////////////////// // signal handling (except suspend/resume)
--- a/src/os/bsd/vm/os_bsd.hpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/os/bsd/vm/os_bsd.hpp Fri Feb 28 08:02:20 2014 -0800 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -134,10 +134,6 @@ // Real-time clock functions static void clock_init(void); - static inline bool supports_monotonic_clock() { - return _clock_gettime != NULL; - } - static int clock_gettime(clockid_t clock_id, struct timespec *tp) { return _clock_gettime ? _clock_gettime(clock_id, tp) : -1; }
--- a/src/os/bsd/vm/os_bsd.inline.hpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/os/bsd/vm/os_bsd.inline.hpp Fri Feb 28 08:02:20 2014 -0800 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -286,4 +286,8 @@ return ::setsockopt(fd, level, optname, optval, optlen); } +inline bool os::supports_monotonic_clock() { + return Bsd::_clock_gettime != NULL; +} + #endif // OS_BSD_VM_OS_BSD_INLINE_HPP
--- a/src/os/linux/vm/os_linux.cpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/os/linux/vm/os_linux.cpp Fri Feb 28 08:02:20 2014 -0800 @@ -1456,7 +1456,7 @@ } jlong os::javaTimeNanos() { - if (Linux::supports_monotonic_clock()) { + if (os::supports_monotonic_clock()) { struct timespec tp; int status = Linux::clock_gettime(CLOCK_MONOTONIC, &tp); assert(status == 0, "gettime error"); @@ -1472,7 +1472,7 @@ } void os::javaTimeNanos_info(jvmtiTimerInfo *info_ptr) { - if (Linux::supports_monotonic_clock()) { + if (os::supports_monotonic_clock()) { info_ptr->max_value = ALL_64_BITS; // CLOCK_MONOTONIC - amount of time since some arbitrary point in the past @@ -3757,85 +3757,6 @@ return ::read(fd, buf, nBytes); } -// TODO-FIXME: reconcile Solaris' os::sleep with the linux variation. -// Solaris uses poll(), linux uses park(). -// Poll() is likely a better choice, assuming that Thread.interrupt() -// generates a SIGUSRx signal. Note that SIGUSR1 can interfere with -// SIGSEGV, see 4355769. - -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(!Linux::supports_monotonic_clock(), "time moving backwards"); - } 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(!Linux::supports_monotonic_clock(), "time moving backwards"); - } else { - millis -= (newtime - prevtime) / NANOSECS_PER_MILLISEC; - } - - if(millis <= 0) break ; - - prevtime = newtime; - slp->park(millis); - } - return OS_OK ; - } -} - // // Short sleep, direct OS call. // @@ -4188,50 +4109,6 @@ guarantee(osthread->sr.is_running(), "Must be running!"); } -//////////////////////////////////////////////////////////////////////////////// -// interrupt support - -void os::interrupt(Thread* thread) { - assert(Thread::current() == thread || Threads_lock->owned_by_self(), - "possibility of dangling Thread pointer"); - - 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) { - assert(Thread::current() == thread || Threads_lock->owned_by_self(), - "possibility of dangling Thread pointer"); - - OSThread* osthread = thread->osthread(); - - bool interrupted = osthread->interrupted(); - - if (interrupted && clear_interrupted) { - osthread->set_interrupted(false); - // consider thread->_SleepEvent->reset() ... optional optimization - } - - return interrupted; -} - /////////////////////////////////////////////////////////////////////////////////// // signal handling (except suspend/resume) @@ -4756,7 +4633,7 @@ fatal(err_msg("pthread_condattr_init: %s", strerror(status))); } // Only set the clock if CLOCK_MONOTONIC is available - if (Linux::supports_monotonic_clock()) { + if (os::supports_monotonic_clock()) { if ((status = pthread_condattr_setclock(_condattr, CLOCK_MONOTONIC)) != 0) { if (status == EINVAL) { warning("Unable to use monotonic clock with relative timed-waits" \ @@ -5586,7 +5463,7 @@ seconds = 50000000; } - if (os::Linux::supports_monotonic_clock()) { + if (os::supports_monotonic_clock()) { struct timespec now; int status = os::Linux::clock_gettime(CLOCK_MONOTONIC, &now); assert_status(status == 0, status, "clock_gettime"); @@ -5803,7 +5680,7 @@ assert (time > 0, "convertTime"); time_t max_secs = 0; - if (!os::Linux::supports_monotonic_clock() || isAbsolute) { + if (!os::supports_monotonic_clock() || isAbsolute) { struct timeval now; int status = gettimeofday(&now, NULL); assert(status == 0, "gettimeofday");
--- a/src/os/linux/vm/os_linux.hpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/os/linux/vm/os_linux.hpp Fri Feb 28 08:02:20 2014 -0800 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -206,10 +206,6 @@ // fast POSIX clocks support static void fast_thread_clock_init(void); - static inline bool supports_monotonic_clock() { - return _clock_gettime != NULL; - } - static int clock_gettime(clockid_t clock_id, struct timespec *tp) { return _clock_gettime ? _clock_gettime(clock_id, tp) : -1; }
--- a/src/os/linux/vm/os_linux.inline.hpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/os/linux/vm/os_linux.inline.hpp Fri Feb 28 08:02:20 2014 -0800 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -288,4 +288,8 @@ return ::setsockopt(fd, level, optname, optval, optlen); } +inline bool os::supports_monotonic_clock() { + return Linux::_clock_gettime != NULL; +} + #endif // OS_LINUX_VM_OS_LINUX_INLINE_HPP
--- a/src/os/posix/vm/os_posix.cpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/os/posix/vm/os_posix.cpp Fri Feb 28 08:02:20 2014 -0800 @@ -1,5 +1,5 @@ /* -* Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,6 +25,7 @@ #include "utilities/globalDefinitions.hpp" #include "prims/jvm.h" #include "runtime/frame.inline.hpp" +#include "runtime/interfaceSupport.hpp" #include "runtime/os.hpp" #include "utilities/vmError.hpp" @@ -315,6 +316,135 @@ 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 ; + } +} + +//////////////////////////////////////////////////////////////////////////////// +// interrupt support + +void os::interrupt(Thread* thread) { + assert(Thread::current() == thread || Threads_lock->owned_by_self(), + "possibility of dangling Thread pointer"); + + 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) { + assert(Thread::current() == thread || Threads_lock->owned_by_self(), + "possibility of dangling Thread pointer"); + + 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; +} + // Returned string is a constant. For unknown signals "UNKNOWN" is returned. const char* os::Posix::get_signal_name(int sig, char* out, size_t outlen) {
--- a/src/os/solaris/vm/os_solaris.cpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/os/solaris/vm/os_solaris.cpp Fri Feb 28 08:02:20 2014 -0800 @@ -332,12 +332,6 @@ ThreadStateTransition::transition(thread, thread_state, _thread_blocked); } -// Version of setup_interruptible() for threads that are already in -// _thread_blocked. Used by os_sleep(). -void os::Solaris::setup_interruptible_already_blocked(JavaThread* thread) { - thread->frame_anchor()->make_walkable(thread); -} - JavaThread* os::Solaris::setup_interruptible() { JavaThread* thread = (JavaThread*)ThreadLocalStorage::thread(); setup_interruptible(thread); @@ -3370,61 +3364,6 @@ return true; } -static int os_sleep(jlong millis, bool interruptible) { - const jlong limit = INT_MAX; - jlong prevtime; - int res; - - while (millis > limit) { - if ((res = os_sleep(limit, interruptible)) != OS_OK) - return res; - millis -= limit; - } - - // Restart interrupted polls with new parameters until the proper delay - // has been completed. - - prevtime = getTimeMillis(); - - while (millis > 0) { - jlong newtime; - - if (!interruptible) { - // Following assert fails for os::yield_all: - // assert(!thread->is_Java_thread(), "must not be java thread"); - res = poll(NULL, 0, millis); - } else { - JavaThread *jt = JavaThread::current(); - - INTERRUPTIBLE_NORESTART_VM_ALWAYS(poll(NULL, 0, millis), res, jt, - os::Solaris::clear_interrupted); - } - - // INTERRUPTIBLE_NORESTART_VM_ALWAYS returns res == OS_INTRPT for - // thread.Interrupt. - - // See c/r 6751923. Poll can return 0 before time - // has elapsed if time is set via clock_settime (as NTP does). - // res == 0 if poll timed out (see man poll RETURN VALUES) - // using the logic below checks that we really did - // sleep at least "millis" if not we'll sleep again. - if( ( res == 0 ) || ((res == OS_ERR) && (errno == EINTR))) { - newtime = getTimeMillis(); - assert(newtime >= prevtime, "time moving backwards"); - /* Doing prevtime and newtime in microseconds doesn't help precision, - and trying to round up to avoid lost milliseconds can result in a - too-short delay. */ - millis -= newtime - prevtime; - if(millis <= 0) - return OS_OK; - prevtime = newtime; - } else - return res; - } - - return OS_OK; -} - // Read calls from inside the vm need to perform state transitions size_t os::read(int fd, void *buf, unsigned int nBytes) { INTERRUPTIBLE_RETURN_INT_VM(::read(fd, buf, nBytes), os::Solaris::clear_interrupted); @@ -3434,69 +3373,6 @@ INTERRUPTIBLE_RETURN_INT(::read(fd, buf, nBytes), os::Solaris::clear_interrupted); } -int os::sleep(Thread* thread, jlong millis, bool interruptible) { - assert(thread == Thread::current(), "thread consistency check"); - - // TODO-FIXME: this should be removed. - // On Solaris machines (especially 2.5.1) we found that sometimes the VM gets into a live lock - // situation with a JavaThread being starved out of a lwp. The kernel doesn't seem to generate - // a SIGWAITING signal which would enable the threads library to create a new lwp for the starving - // thread. We suspect that because the Watcher thread keeps waking up at periodic intervals the kernel - // is fooled into believing that the system is making progress. In the code below we block the - // the watcher thread while safepoint is in progress so that it would not appear as though the - // system is making progress. - if (!Solaris::T2_libthread() && - thread->is_Watcher_thread() && SafepointSynchronize::is_synchronizing() && !Arguments::has_profile()) { - // We now try to acquire the threads lock. Since this lock is held by the VM thread during - // the entire safepoint, the watcher thread will line up here during the safepoint. - Threads_lock->lock_without_safepoint_check(); - Threads_lock->unlock(); - } - - if (thread->is_Java_thread()) { - // This is a JavaThread so we honor the _thread_blocked protocol - // even for sleeps of 0 milliseconds. This was originally done - // as a workaround for bug 4338139. However, now we also do it - // to honor the suspend-equivalent protocol. - - JavaThread *jt = (JavaThread *) thread; - ThreadBlockInVM tbivm(jt); - - jt->set_suspend_equivalent(); - // cleared by handle_special_suspend_equivalent_condition() or - // java_suspend_self() via check_and_wait_while_suspended() - - int ret_code; - if (millis <= 0) { - thr_yield(); - ret_code = 0; - } else { - // The original sleep() implementation did not create an - // OSThreadWaitState helper for sleeps of 0 milliseconds. - // I'm preserving that decision for now. - OSThreadWaitState osts(jt->osthread(), false /* not Object.wait() */); - - ret_code = os_sleep(millis, interruptible); - } - - // were we externally suspended while we were waiting? - jt->check_and_wait_while_suspended(); - - return ret_code; - } - - // non-JavaThread from this point on: - - if (millis <= 0) { - thr_yield(); - return 0; - } - - OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */); - - return os_sleep(millis, interruptible); -} - void os::naked_short_sleep(jlong ms) { assert(ms < 1000, "Un-interruptable sleep, short time use only"); @@ -4139,68 +4015,6 @@ errno = old_errno; } - -void os::interrupt(Thread* thread) { - assert(Thread::current() == thread || Threads_lock->owned_by_self(), "possibility of dangling Thread pointer"); - - OSThread* osthread = thread->osthread(); - - int isInterrupted = osthread->interrupted(); - if (!isInterrupted) { - osthread->set_interrupted(true); - OrderAccess::fence(); - // os::sleep() is implemented with either poll (NULL,0,timeout) or - // by parking on _SleepEvent. If the former, thr_kill will unwedge - // the sleeper by SIGINTR, otherwise the unpark() will wake the sleeper. - ParkEvent * const slp = thread->_SleepEvent ; - if (slp != NULL) slp->unpark() ; - } - - // For JSR166: unpark after setting status but before thr_kill -dl - if (thread->is_Java_thread()) { - ((JavaThread*)thread)->parker()->unpark(); - } - - // Handle interruptible wait() ... - ParkEvent * const ev = thread->_ParkEvent ; - if (ev != NULL) ev->unpark() ; - - // When events are used everywhere for os::sleep, then this thr_kill - // will only be needed if UseVMInterruptibleIO is true. - - if (!isInterrupted) { - int status = thr_kill(osthread->thread_id(), os::Solaris::SIGinterrupt()); - assert_status(status == 0, status, "thr_kill"); - - // Bump thread interruption counter - RuntimeService::record_thread_interrupt_signaled_count(); - } -} - - -bool os::is_interrupted(Thread* thread, bool clear_interrupted) { - assert(Thread::current() == thread || Threads_lock->owned_by_self(), "possibility of dangling Thread pointer"); - - OSThread* osthread = thread->osthread(); - - bool res = osthread->interrupted(); - - // NOTE that since there is no "lock" around these two operations, - // there is the possibility that the interrupted flag will be - // "false" but that the interrupt event will be set. This is - // intentional. The effect of this is that Object.wait() will appear - // to have a spurious wakeup, which is not harmful, and the - // possibility is so rare that it is not worth the added complexity - // to add yet another lock. It has also been recommended not to put - // the interrupted flag into the os::Solaris::Event structure, - // because it hides the issue. - if (res && clear_interrupted) { - osthread->set_interrupted(false); - } - return res; -} - - void os::print_statistics() { }
--- a/src/os/solaris/vm/os_solaris.inline.hpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/os/solaris/vm/os_solaris.inline.hpp Fri Feb 28 08:02:20 2014 -0800 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -260,4 +260,10 @@ const char *optval, socklen_t optlen) { return ::setsockopt(fd, level, optname, optval, optlen); } + +inline bool os::supports_monotonic_clock() { + // javaTimeNanos() is monotonic on Solaris, see getTimeNanos() comments + return true; +} + #endif // OS_SOLARIS_VM_OS_SOLARIS_INLINE_HPP
--- a/src/os/windows/vm/os_windows.cpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/os/windows/vm/os_windows.cpp Fri Feb 28 08:02:20 2014 -0800 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -628,8 +628,6 @@ delete osthread; } - -static int has_performance_count = 0; static jlong first_filetime; static jlong initial_performance_count; static jlong performance_frequency; @@ -645,7 +643,7 @@ jlong os::elapsed_counter() { LARGE_INTEGER count; - if (has_performance_count) { + if (win32::_has_performance_count) { QueryPerformanceCounter(&count); return as_long(count) - initial_performance_count; } else { @@ -657,7 +655,7 @@ jlong os::elapsed_frequency() { - if (has_performance_count) { + if (win32::_has_performance_count) { return performance_frequency; } else { // the FILETIME time is the number of 100-nanosecond intervals since January 1,1601. @@ -736,15 +734,15 @@ return false; } -static void initialize_performance_counter() { +void os::win32::initialize_performance_counter() { LARGE_INTEGER count; if (QueryPerformanceFrequency(&count)) { - has_performance_count = 1; + win32::_has_performance_count = 1; performance_frequency = as_long(count); QueryPerformanceCounter(&count); initial_performance_count = as_long(count); } else { - has_performance_count = 0; + win32::_has_performance_count = 0; FILETIME wt; GetSystemTimeAsFileTime(&wt); first_filetime = jlong_from(wt.dwHighDateTime, wt.dwLowDateTime); @@ -839,7 +837,7 @@ } jlong os::javaTimeNanos() { - if (!has_performance_count) { + if (!win32::_has_performance_count) { return javaTimeMillis() * NANOSECS_PER_MILLISEC; // the best we can do. } else { LARGE_INTEGER current_count; @@ -852,7 +850,7 @@ } void os::javaTimeNanos_info(jvmtiTimerInfo *info_ptr) { - if (!has_performance_count) { + if (!win32::_has_performance_count) { // javaTimeMillis() doesn't have much percision, // but it is not going to wrap -- so all 64 bits info_ptr->max_value = ALL_64_BITS; @@ -3682,6 +3680,8 @@ bool os::win32::_is_windows_2003 = false; bool os::win32::_is_windows_server = false; +bool os::win32::_has_performance_count = 0; + void os::win32::initialize_system_info() { SYSTEM_INFO si; GetSystemInfo(&si);
--- a/src/os/windows/vm/os_windows.hpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/os/windows/vm/os_windows.hpp Fri Feb 28 08:02:20 2014 -0800 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -42,6 +42,7 @@ static bool _is_nt; static bool _is_windows_2003; static bool _is_windows_server; + static bool _has_performance_count; static void print_windows_version(outputStream* st); @@ -63,6 +64,9 @@ // load dll from Windows system directory or Windows directory static HINSTANCE load_Windows_dll(const char* name, char *ebuf, int ebuflen); + private: + static void initialize_performance_counter(); + public: // Generic interface:
--- a/src/os/windows/vm/os_windows.inline.hpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/os/windows/vm/os_windows.inline.hpp Fri Feb 28 08:02:20 2014 -0800 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -107,6 +107,10 @@ return ::close(fd); } +inline bool os::supports_monotonic_clock() { + return win32::_has_performance_count; +} + #ifndef PRODUCT #define CALL_TEST_FUNC_WITH_WRAPPER_IF_NEEDED(f) \ os::win32::call_test_func_with_wrapper(f)
--- a/src/share/vm/c1/c1_GraphBuilder.cpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/c1/c1_GraphBuilder.cpp Fri Feb 28 08:02:20 2014 -0800 @@ -2276,7 +2276,7 @@ if (!has_handler() && (!instruction->needs_exception_state() || instruction->exception_state() != NULL)) { assert(instruction->exception_state() == NULL || instruction->exception_state()->kind() == ValueStack::EmptyExceptionState - || (instruction->exception_state()->kind() == ValueStack::ExceptionState && _compilation->env()->jvmti_can_access_local_variables()), + || (instruction->exception_state()->kind() == ValueStack::ExceptionState && _compilation->env()->should_retain_local_variables()), "exception_state should be of exception kind"); return new XHandlers(); } @@ -2367,7 +2367,7 @@ // This scope and all callees do not handle exceptions, so the local // variables of this scope are not needed. However, the scope itself is // required for a correct exception stack trace -> clear out the locals. - if (_compilation->env()->jvmti_can_access_local_variables()) { + if (_compilation->env()->should_retain_local_variables()) { cur_state = cur_state->copy(ValueStack::ExceptionState, cur_state->bci()); } else { cur_state = cur_state->copy(ValueStack::EmptyExceptionState, cur_state->bci()); @@ -3251,7 +3251,7 @@ ValueStack* GraphBuilder::copy_state_for_exception_with_bci(int bci) { ValueStack* s = copy_state_exhandling_with_bci(bci); if (s == NULL) { - if (_compilation->env()->jvmti_can_access_local_variables()) { + if (_compilation->env()->should_retain_local_variables()) { s = state()->copy(ValueStack::ExceptionState, bci); } else { s = state()->copy(ValueStack::EmptyExceptionState, bci);
--- a/src/share/vm/c1/c1_Instruction.cpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/c1/c1_Instruction.cpp Fri Feb 28 08:02:20 2014 -0800 @@ -76,7 +76,7 @@ void Instruction::update_exception_state(ValueStack* state) { if (state != NULL && (state->kind() == ValueStack::EmptyExceptionState || state->kind() == ValueStack::ExceptionState)) { - assert(state->kind() == ValueStack::EmptyExceptionState || Compilation::current()->env()->jvmti_can_access_local_variables(), "unexpected state kind"); + assert(state->kind() == ValueStack::EmptyExceptionState || Compilation::current()->env()->should_retain_local_variables(), "unexpected state kind"); _exception_state = state; } else { _exception_state = NULL;
--- a/src/share/vm/c1/c1_ValueStack.cpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/c1/c1_ValueStack.cpp Fri Feb 28 08:02:20 2014 -0800 @@ -52,7 +52,7 @@ , _stack() , _locks(copy_from->locks_size()) { - assert(kind != EmptyExceptionState || !Compilation::current()->env()->jvmti_can_access_local_variables(), "need locals"); + assert(kind != EmptyExceptionState || !Compilation::current()->env()->should_retain_local_variables(), "need locals"); if (kind != EmptyExceptionState) { // only allocate space if we need to copy the locals-array _locals = Values(copy_from->locals_size());
--- a/src/share/vm/c1/c1_ValueStack.hpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/c1/c1_ValueStack.hpp Fri Feb 28 08:02:20 2014 -0800 @@ -75,7 +75,7 @@ void set_caller_state(ValueStack* s) { assert(kind() == EmptyExceptionState || - (Compilation::current()->env()->jvmti_can_access_local_variables() && kind() == ExceptionState), + (Compilation::current()->env()->should_retain_local_variables() && kind() == ExceptionState), "only EmptyExceptionStates can be modified"); _caller_state = s; }
--- a/src/share/vm/ci/ciEnv.cpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/ci/ciEnv.cpp Fri Feb 28 08:02:20 2014 -0800 @@ -136,6 +136,11 @@ _ClassCastException_instance = NULL; _the_null_string = NULL; _the_min_jint_string = NULL; + + _jvmti_can_hotswap_or_post_breakpoint = false; + _jvmti_can_access_local_variables = false; + _jvmti_can_post_on_exceptions = false; + _jvmti_can_pop_frame = false; } ciEnv::ciEnv(Arena* arena) { @@ -186,6 +191,11 @@ _ClassCastException_instance = NULL; _the_null_string = NULL; _the_min_jint_string = NULL; + + _jvmti_can_hotswap_or_post_breakpoint = false; + _jvmti_can_access_local_variables = false; + _jvmti_can_post_on_exceptions = false; + _jvmti_can_pop_frame = false; } ciEnv::~ciEnv() { @@ -205,6 +215,31 @@ _jvmti_can_hotswap_or_post_breakpoint = JvmtiExport::can_hotswap_or_post_breakpoint(); _jvmti_can_access_local_variables = JvmtiExport::can_access_local_variables(); _jvmti_can_post_on_exceptions = JvmtiExport::can_post_on_exceptions(); + _jvmti_can_pop_frame = JvmtiExport::can_pop_frame(); +} + +bool ciEnv::should_retain_local_variables() const { + return _jvmti_can_access_local_variables || _jvmti_can_pop_frame; +} + +bool ciEnv::jvmti_state_changed() const { + if (!_jvmti_can_access_local_variables && + JvmtiExport::can_access_local_variables()) { + return true; + } + if (!_jvmti_can_hotswap_or_post_breakpoint && + JvmtiExport::can_hotswap_or_post_breakpoint()) { + return true; + } + if (!_jvmti_can_post_on_exceptions && + JvmtiExport::can_post_on_exceptions()) { + return true; + } + if (!_jvmti_can_pop_frame && + JvmtiExport::can_pop_frame()) { + return true; + } + return false; } // ------------------------------------------------------------------ @@ -940,13 +975,7 @@ No_Safepoint_Verifier nsv; // Change in Jvmti state may invalidate compilation. - if (!failing() && - ( (!jvmti_can_hotswap_or_post_breakpoint() && - JvmtiExport::can_hotswap_or_post_breakpoint()) || - (!jvmti_can_access_local_variables() && - JvmtiExport::can_access_local_variables()) || - (!jvmti_can_post_on_exceptions() && - JvmtiExport::can_post_on_exceptions()) )) { + if (!failing() && jvmti_state_changed()) { record_failure("Jvmti state change invalidated dependencies"); }
--- a/src/share/vm/ci/ciEnv.hpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/ci/ciEnv.hpp Fri Feb 28 08:02:20 2014 -0800 @@ -69,6 +69,7 @@ bool _jvmti_can_hotswap_or_post_breakpoint; bool _jvmti_can_access_local_variables; bool _jvmti_can_post_on_exceptions; + bool _jvmti_can_pop_frame; // Cache DTrace flags bool _dtrace_extended_probes; @@ -332,8 +333,9 @@ // Cache Jvmti state void cache_jvmti_state(); + bool jvmti_state_changed() const; + bool should_retain_local_variables() const; bool jvmti_can_hotswap_or_post_breakpoint() const { return _jvmti_can_hotswap_or_post_breakpoint; } - bool jvmti_can_access_local_variables() const { return _jvmti_can_access_local_variables; } bool jvmti_can_post_on_exceptions() const { return _jvmti_can_post_on_exceptions; } // Cache DTrace flags
--- a/src/share/vm/ci/ciMethod.cpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/ci/ciMethod.cpp Fri Feb 28 08:02:20 2014 -0800 @@ -412,7 +412,7 @@ // information. MethodLivenessResult ciMethod::liveness_at_bci(int bci) { MethodLivenessResult result = raw_liveness_at_bci(bci); - if (CURRENT_ENV->jvmti_can_access_local_variables() || DeoptimizeALot || CompileTheWorld) { + if (CURRENT_ENV->should_retain_local_variables() || DeoptimizeALot || CompileTheWorld) { // Keep all locals live for the user's edification and amusement. result.at_put_range(0, result.size(), true); }
--- a/src/share/vm/classfile/classLoaderData.cpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/classfile/classLoaderData.cpp Fri Feb 28 08:02:20 2014 -0800 @@ -73,7 +73,11 @@ ClassLoaderData::ClassLoaderData(Handle h_class_loader, bool is_anonymous, Dependencies dependencies) : _class_loader(h_class_loader()), - _is_anonymous(is_anonymous), _keep_alive(is_anonymous), // initially + _is_anonymous(is_anonymous), + // An anonymous class loader data doesn't have anything to keep + // it from being unloaded during parsing of the anonymous class. + // The null-class-loader should always be kept alive. + _keep_alive(is_anonymous || h_class_loader.is_null()), _metaspace(NULL), _unloading(false), _klasses(NULL), _claimed(0), _jmethod_ids(NULL), _handles(NULL), _deallocate_list(NULL), _next(NULL), _dependencies(dependencies), @@ -317,11 +321,15 @@ } } +oop ClassLoaderData::keep_alive_object() const { + assert(!keep_alive(), "Don't use with CLDs that are artificially kept alive"); + return is_anonymous() ? _klasses->java_mirror() : class_loader(); +} + bool ClassLoaderData::is_alive(BoolObjectClosure* is_alive_closure) const { - bool alive = - is_anonymous() ? - is_alive_closure->do_object_b(_klasses->java_mirror()) : - class_loader() == NULL || is_alive_closure->do_object_b(class_loader()); + bool alive = keep_alive() // null class loader and incomplete anonymous klasses. + || is_alive_closure->do_object_b(keep_alive_object()); + assert(!alive || claimed(), "must be claimed"); return alive; } @@ -598,8 +606,6 @@ void ClassLoaderDataGraph::always_strong_oops_do(OopClosure* f, KlassClosure* klass_closure, bool must_claim) { if (ClassUnloading) { - ClassLoaderData::the_null_class_loader_data()->oops_do(f, klass_closure, must_claim); - // keep any special CLDs alive. ClassLoaderDataGraph::keep_alive_oops_do(f, klass_closure, must_claim); } else { ClassLoaderDataGraph::oops_do(f, klass_closure, must_claim); @@ -705,7 +711,7 @@ bool has_redefined_a_class = JvmtiExport::has_redefined_a_class(); MetadataOnStackMark md_on_stack; while (data != NULL) { - if (data->keep_alive() || data->is_alive(is_alive_closure)) { + if (data->is_alive(is_alive_closure)) { if (has_redefined_a_class) { data->classes_do(InstanceKlass::purge_previous_versions); }
--- a/src/share/vm/classfile/classLoaderData.hpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/classfile/classLoaderData.hpp Fri Feb 28 08:02:20 2014 -0800 @@ -139,7 +139,7 @@ // classes in the class loader are allocated. Mutex* _metaspace_lock; // Locks the metaspace for allocations and setup. bool _unloading; // true if this class loader goes away - bool _keep_alive; // if this CLD can be unloaded for anonymous loaders + bool _keep_alive; // if this CLD is kept alive without a keep_alive_object(). bool _is_anonymous; // if this CLD is for an anonymous class volatile int _claimed; // true if claimed, for example during GC traces. // To avoid applying oop closure more than once. @@ -230,13 +230,16 @@ oop class_loader() const { return _class_loader; } + // The object the GC is using to keep this ClassLoaderData alive. + oop keep_alive_object() const; + // Returns true if this class loader data is for a loader going away. bool is_unloading() const { assert(!(is_the_null_class_loader_data() && _unloading), "The null class loader can never be unloaded"); return _unloading; } - // Anonymous class loader data doesn't have anything to keep them from - // being unloaded during parsing the anonymous class. + + // Used to make sure that this CLD is not unloaded. void set_keep_alive(bool value) { _keep_alive = value; } unsigned int identity_hash() {
--- a/src/share/vm/classfile/javaClasses.cpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/classfile/javaClasses.cpp Fri Feb 28 08:02:20 2014 -0800 @@ -461,12 +461,11 @@ return true; } -void java_lang_String::print(Handle java_string, outputStream* st) { - oop obj = java_string(); - assert(obj->klass() == SystemDictionary::String_klass(), "must be java_string"); - typeArrayOop value = java_lang_String::value(obj); - int offset = java_lang_String::offset(obj); - int length = java_lang_String::length(obj); +void java_lang_String::print(oop java_string, outputStream* st) { + assert(java_string->klass() == SystemDictionary::String_klass(), "must be java_string"); + typeArrayOop value = java_lang_String::value(java_string); + int offset = java_lang_String::offset(java_string); + int length = java_lang_String::length(java_string); int end = MIN2(length, 100); if (value == NULL) {
--- a/src/share/vm/classfile/javaClasses.hpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/classfile/javaClasses.hpp Fri Feb 28 08:02:20 2014 -0800 @@ -198,7 +198,7 @@ } // Debugging - static void print(Handle java_string, outputStream* st); + static void print(oop java_string, outputStream* st); friend class JavaClasses; };
--- a/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp Fri Feb 28 08:02:20 2014 -0800 @@ -4534,7 +4534,7 @@ G1ParGCAllocBuffer::G1ParGCAllocBuffer(size_t gclab_word_size) : ParGCAllocBuffer(gclab_word_size), _retired(false) { } -G1ParScanThreadState::G1ParScanThreadState(G1CollectedHeap* g1h, uint queue_num) +G1ParScanThreadState::G1ParScanThreadState(G1CollectedHeap* g1h, uint queue_num, ReferenceProcessor* rp) : _g1h(g1h), _refs(g1h->task_queue(queue_num)), _dcq(&g1h->dirty_card_queue_set()), @@ -4544,7 +4544,7 @@ _term_attempts(0), _surviving_alloc_buffer(g1h->desired_plab_sz(GCAllocForSurvived)), _tenured_alloc_buffer(g1h->desired_plab_sz(GCAllocForTenured)), - _age_table(false), + _age_table(false), _scanner(g1h, this, rp), _strong_roots_time(0), _term_time(0), _alloc_buffer_waste(0), _undo_waste(0) { // we allocate G1YoungSurvRateNumRegions plus one entries, since @@ -4653,14 +4653,10 @@ G1ParClosureSuper::G1ParClosureSuper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) : - _g1(g1), _g1_rem(_g1->g1_rem_set()), _cm(_g1->concurrent_mark()), - _par_scan_state(par_scan_state), - _worker_id(par_scan_state->queue_num()), - _during_initial_mark(_g1->g1_policy()->during_initial_mark_pause()), - _mark_in_progress(_g1->mark_in_progress()) { } - -template <G1Barrier barrier, bool do_mark_object> -void G1ParCopyClosure<barrier, do_mark_object>::mark_object(oop obj) { + _g1(g1), _par_scan_state(par_scan_state), + _worker_id(par_scan_state->queue_num()) { } + +void G1ParCopyHelper::mark_object(oop obj) { #ifdef ASSERT HeapRegion* hr = _g1->heap_region_containing(obj); assert(hr != NULL, "sanity"); @@ -4671,9 +4667,7 @@ _cm->grayRoot(obj, (size_t) obj->size(), _worker_id); } -template <G1Barrier barrier, bool do_mark_object> -void G1ParCopyClosure<barrier, do_mark_object> - ::mark_forwarded_object(oop from_obj, oop to_obj) { +void G1ParCopyHelper::mark_forwarded_object(oop from_obj, oop to_obj) { #ifdef ASSERT assert(from_obj->is_forwarded(), "from obj should be forwarded"); assert(from_obj->forwardee() == to_obj, "to obj should be the forwardee"); @@ -4695,27 +4689,25 @@ _cm->grayRoot(to_obj, (size_t) from_obj->size(), _worker_id); } -template <G1Barrier barrier, bool do_mark_object> -oop G1ParCopyClosure<barrier, do_mark_object> - ::copy_to_survivor_space(oop old) { +oop G1ParScanThreadState::copy_to_survivor_space(oop const old) { size_t word_sz = old->size(); - HeapRegion* from_region = _g1->heap_region_containing_raw(old); + HeapRegion* from_region = _g1h->heap_region_containing_raw(old); // +1 to make the -1 indexes valid... int young_index = from_region->young_index_in_cset()+1; assert( (from_region->is_young() && young_index > 0) || (!from_region->is_young() && young_index == 0), "invariant" ); - G1CollectorPolicy* g1p = _g1->g1_policy(); + G1CollectorPolicy* g1p = _g1h->g1_policy(); markOop m = old->mark(); int age = m->has_displaced_mark_helper() ? m->displaced_mark_helper()->age() : m->age(); GCAllocPurpose alloc_purpose = g1p->evacuation_destination(from_region, age, word_sz); - HeapWord* obj_ptr = _par_scan_state->allocate(alloc_purpose, word_sz); + HeapWord* obj_ptr = allocate(alloc_purpose, word_sz); #ifndef PRODUCT // Should this evacuation fail? - if (_g1->evacuation_should_fail()) { + if (_g1h->evacuation_should_fail()) { if (obj_ptr != NULL) { - _par_scan_state->undo_allocation(alloc_purpose, obj_ptr, word_sz); + undo_allocation(alloc_purpose, obj_ptr, word_sz); obj_ptr = NULL; } } @@ -4724,7 +4716,7 @@ if (obj_ptr == NULL) { // This will either forward-to-self, or detect that someone else has // installed a forwarding pointer. - return _g1->handle_evacuation_failure_par(_par_scan_state, old); + return _g1h->handle_evacuation_failure_par(this, old); } oop obj = oop(obj_ptr); @@ -4757,12 +4749,12 @@ m = m->incr_age(); obj->set_mark(m); } - _par_scan_state->age_table()->add(obj, word_sz); + age_table()->add(obj, word_sz); } else { obj->set_mark(m); } - size_t* surv_young_words = _par_scan_state->surviving_young_words(); + size_t* surv_young_words = surviving_young_words(); surv_young_words[young_index] += word_sz; if (obj->is_objArray() && arrayOop(obj)->length() >= ParGCArrayScanChunk) { @@ -4771,15 +4763,15 @@ // length field of the from-space object. arrayOop(obj)->set_length(0); oop* old_p = set_partial_array_mask(old); - _par_scan_state->push_on_queue(old_p); + push_on_queue(old_p); } else { // No point in using the slower heap_region_containing() method, // given that we know obj is in the heap. - _scanner.set_region(_g1->heap_region_containing_raw(obj)); + _scanner.set_region(_g1h->heap_region_containing_raw(obj)); obj->oop_iterate_backwards(&_scanner); } } else { - _par_scan_state->undo_allocation(alloc_purpose, obj_ptr, word_sz); + undo_allocation(alloc_purpose, obj_ptr, word_sz); obj = forward_ptr; } return obj; @@ -4794,19 +4786,23 @@ template <G1Barrier barrier, bool do_mark_object> template <class T> -void G1ParCopyClosure<barrier, do_mark_object> -::do_oop_work(T* p) { - oop obj = oopDesc::load_decode_heap_oop(p); +void G1ParCopyClosure<barrier, do_mark_object>::do_oop_work(T* p) { + T heap_oop = oopDesc::load_heap_oop(p); + + if (oopDesc::is_null(heap_oop)) { + return; + } + + oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); assert(_worker_id == _par_scan_state->queue_num(), "sanity"); - // here the null check is implicit in the cset_fast_test() test if (_g1->in_cset_fast_test(obj)) { oop forwardee; if (obj->is_forwarded()) { forwardee = obj->forwardee(); } else { - forwardee = copy_to_survivor_space(obj); + forwardee = _par_scan_state->copy_to_survivor_space(obj); } assert(forwardee != NULL, "forwardee should not be NULL"); oopDesc::encode_store_heap_oop(p, forwardee); @@ -4823,12 +4819,12 @@ // The object is not in collection set. If we're a root scanning // closure during an initial mark pause (i.e. do_mark_object will // be true) then attempt to mark the object. - if (do_mark_object && _g1->is_in_g1_reserved(obj)) { + if (do_mark_object) { mark_object(obj); } } - if (barrier == G1BarrierEvac && obj != NULL) { + if (barrier == G1BarrierEvac) { _par_scan_state->update_rs(_from, p, _worker_id); } } @@ -5025,7 +5021,7 @@ ReferenceProcessor* rp = _g1h->ref_processor_stw(); - G1ParScanThreadState pss(_g1h, worker_id); + G1ParScanThreadState pss(_g1h, worker_id, rp); G1ParScanHeapEvacClosure scan_evac_cl(_g1h, &pss, rp); G1ParScanHeapEvacFailureClosure evac_failure_cl(_g1h, &pss, rp); G1ParScanPartialArrayClosure partial_scan_cl(_g1h, &pss, rp); @@ -5456,7 +5452,7 @@ G1STWIsAliveClosure is_alive(_g1h); - G1ParScanThreadState pss(_g1h, worker_id); + G1ParScanThreadState pss(_g1h, worker_id, NULL); G1ParScanHeapEvacClosure scan_evac_cl(_g1h, &pss, NULL); G1ParScanHeapEvacFailureClosure evac_failure_cl(_g1h, &pss, NULL); @@ -5568,7 +5564,7 @@ ResourceMark rm; HandleMark hm; - G1ParScanThreadState pss(_g1h, worker_id); + G1ParScanThreadState pss(_g1h, worker_id, NULL); G1ParScanHeapEvacClosure scan_evac_cl(_g1h, &pss, NULL); G1ParScanHeapEvacFailureClosure evac_failure_cl(_g1h, &pss, NULL); G1ParScanPartialArrayClosure partial_scan_cl(_g1h, &pss, NULL); @@ -5694,7 +5690,7 @@ // JNI refs. // Use only a single queue for this PSS. - G1ParScanThreadState pss(this, 0); + G1ParScanThreadState pss(this, 0, NULL); // We do not embed a reference processor in the copying/scanning // closures while we're actually processing the discovered
--- a/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp Fri Feb 28 08:02:20 2014 -0800 @@ -606,6 +606,11 @@ // may not be a humongous - it must fit into a single heap region. HeapWord* par_allocate_during_gc(GCAllocPurpose purpose, size_t word_size); + HeapWord* allocate_during_gc_slow(GCAllocPurpose purpose, + HeapRegion* alloc_region, + bool par, + size_t word_size); + // Ensure that no further allocations can happen in "r", bearing in mind // that parallel threads might be attempting allocations. void par_allocate_remaining_space(HeapRegion* r); @@ -698,23 +703,20 @@ } // This is a fast test on whether a reference points into the - // collection set or not. It does not assume that the reference - // points into the heap; if it doesn't, it will return false. + // collection set or not. Assume that the reference + // points into the heap. bool in_cset_fast_test(oop obj) { assert(_in_cset_fast_test != NULL, "sanity"); - if (_g1_committed.contains((HeapWord*) obj)) { - // no need to subtract the bottom of the heap from obj, - // _in_cset_fast_test is biased - uintx index = cast_from_oop<uintx>(obj) >> HeapRegion::LogOfHRGrainBytes; - bool ret = _in_cset_fast_test[index]; - // let's make sure the result is consistent with what the slower - // test returns - assert( ret || !obj_in_cs(obj), "sanity"); - assert(!ret || obj_in_cs(obj), "sanity"); - return ret; - } else { - return false; - } + assert(_g1_committed.contains((HeapWord*) obj), err_msg("Given reference outside of heap, is "PTR_FORMAT, (HeapWord*)obj)); + // no need to subtract the bottom of the heap from obj, + // _in_cset_fast_test is biased + uintx index = cast_from_oop<uintx>(obj) >> HeapRegion::LogOfHRGrainBytes; + bool ret = _in_cset_fast_test[index]; + // let's make sure the result is consistent with what the slower + // test returns + assert( ret || !obj_in_cs(obj), "sanity"); + assert(!ret || obj_in_cs(obj), "sanity"); + return ret; } void clear_cset_fast_test() { @@ -1774,95 +1776,6 @@ ParGCAllocBuffer::retire(end_of_gc, retain); _retired = true; } - - bool is_retired() { - return _retired; - } -}; - -class G1ParGCAllocBufferContainer { -protected: - static int const _priority_max = 2; - G1ParGCAllocBuffer* _priority_buffer[_priority_max]; - -public: - G1ParGCAllocBufferContainer(size_t gclab_word_size) { - for (int pr = 0; pr < _priority_max; ++pr) { - _priority_buffer[pr] = new G1ParGCAllocBuffer(gclab_word_size); - } - } - - ~G1ParGCAllocBufferContainer() { - for (int pr = 0; pr < _priority_max; ++pr) { - assert(_priority_buffer[pr]->is_retired(), "alloc buffers should all retire at this point."); - delete _priority_buffer[pr]; - } - } - - HeapWord* allocate(size_t word_sz) { - HeapWord* obj; - for (int pr = 0; pr < _priority_max; ++pr) { - obj = _priority_buffer[pr]->allocate(word_sz); - if (obj != NULL) return obj; - } - return obj; - } - - bool contains(void* addr) { - for (int pr = 0; pr < _priority_max; ++pr) { - if (_priority_buffer[pr]->contains(addr)) return true; - } - return false; - } - - void undo_allocation(HeapWord* obj, size_t word_sz) { - bool finish_undo; - for (int pr = 0; pr < _priority_max; ++pr) { - if (_priority_buffer[pr]->contains(obj)) { - _priority_buffer[pr]->undo_allocation(obj, word_sz); - finish_undo = true; - } - } - if (!finish_undo) ShouldNotReachHere(); - } - - size_t words_remaining() { - size_t result = 0; - for (int pr = 0; pr < _priority_max; ++pr) { - result += _priority_buffer[pr]->words_remaining(); - } - return result; - } - - size_t words_remaining_in_retired_buffer() { - G1ParGCAllocBuffer* retired = _priority_buffer[0]; - return retired->words_remaining(); - } - - void flush_stats_and_retire(PLABStats* stats, bool end_of_gc, bool retain) { - for (int pr = 0; pr < _priority_max; ++pr) { - _priority_buffer[pr]->flush_stats_and_retire(stats, end_of_gc, retain); - } - } - - void update(bool end_of_gc, bool retain, HeapWord* buf, size_t word_sz) { - G1ParGCAllocBuffer* retired_and_set = _priority_buffer[0]; - retired_and_set->retire(end_of_gc, retain); - retired_and_set->set_buf(buf); - retired_and_set->set_word_size(word_sz); - adjust_priority_order(); - } - -private: - void adjust_priority_order() { - G1ParGCAllocBuffer* retired_and_set = _priority_buffer[0]; - - int last = _priority_max - 1; - for (int pr = 0; pr < last; ++pr) { - _priority_buffer[pr] = _priority_buffer[pr + 1]; - } - _priority_buffer[last] = retired_and_set; - } }; class G1ParScanThreadState : public StackObj { @@ -1873,11 +1786,13 @@ G1SATBCardTableModRefBS* _ct_bs; G1RemSet* _g1_rem; - G1ParGCAllocBufferContainer _surviving_alloc_buffer; - G1ParGCAllocBufferContainer _tenured_alloc_buffer; - G1ParGCAllocBufferContainer* _alloc_buffers[GCAllocPurposeCount]; + G1ParGCAllocBuffer _surviving_alloc_buffer; + G1ParGCAllocBuffer _tenured_alloc_buffer; + G1ParGCAllocBuffer* _alloc_buffers[GCAllocPurposeCount]; ageTable _age_table; + G1ParScanClosure _scanner; + size_t _alloc_buffer_waste; size_t _undo_waste; @@ -1930,7 +1845,7 @@ } public: - G1ParScanThreadState(G1CollectedHeap* g1h, uint queue_num); + G1ParScanThreadState(G1CollectedHeap* g1h, uint queue_num, ReferenceProcessor* rp); ~G1ParScanThreadState() { FREE_C_HEAP_ARRAY(size_t, _surviving_young_words_base, mtGC); @@ -1939,7 +1854,7 @@ RefToScanQueue* refs() { return _refs; } ageTable* age_table() { return &_age_table; } - G1ParGCAllocBufferContainer* alloc_buffer(GCAllocPurpose purpose) { + G1ParGCAllocBuffer* alloc_buffer(GCAllocPurpose purpose) { return _alloc_buffers[purpose]; } @@ -1969,13 +1884,15 @@ HeapWord* obj = NULL; size_t gclab_word_size = _g1h->desired_plab_sz(purpose); if (word_sz * 100 < gclab_word_size * ParallelGCBufferWastePct) { - G1ParGCAllocBufferContainer* alloc_buf = alloc_buffer(purpose); + G1ParGCAllocBuffer* alloc_buf = alloc_buffer(purpose); + add_to_alloc_buffer_waste(alloc_buf->words_remaining()); + alloc_buf->retire(false /* end_of_gc */, false /* retain */); HeapWord* buf = _g1h->par_allocate_during_gc(purpose, gclab_word_size); if (buf == NULL) return NULL; // Let caller handle allocation failure. - - add_to_alloc_buffer_waste(alloc_buf->words_remaining_in_retired_buffer()); - alloc_buf->update(false /* end_of_gc */, false /* retain */, buf, gclab_word_size); + // Otherwise. + alloc_buf->set_word_size(gclab_word_size); + alloc_buf->set_buf(buf); obj = alloc_buf->allocate(word_sz); assert(obj != NULL, "buffer was definitely big enough..."); @@ -2065,6 +1982,8 @@ } } + oop copy_to_survivor_space(oop const obj); + template <class T> void deal_with_reference(T* ref_to_scan) { if (has_partial_array_mask(ref_to_scan)) { _partial_scan_cl->do_oop_nv(ref_to_scan); @@ -2087,6 +2006,7 @@ } } +public: void trim_queue(); };
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/vm/gc_implementation/g1/g1OopClosures.cpp Fri Feb 28 08:02:20 2014 -0800 @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#include "precompiled.hpp" +#include "gc_implementation/g1/g1CollectedHeap.inline.hpp" +#include "gc_implementation/g1/g1OopClosures.inline.hpp" + +G1ParCopyHelper::G1ParCopyHelper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) : + G1ParClosureSuper(g1, par_scan_state), _scanned_klass(NULL), + _cm(_g1->concurrent_mark()) {}
--- a/src/share/vm/gc_implementation/g1/g1OopClosures.hpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/gc_implementation/g1/g1OopClosures.hpp Fri Feb 28 08:02:20 2014 -0800 @@ -48,12 +48,8 @@ class G1ParClosureSuper : public OopsInHeapRegionClosure { protected: G1CollectedHeap* _g1; - G1RemSet* _g1_rem; - ConcurrentMark* _cm; G1ParScanThreadState* _par_scan_state; uint _worker_id; - bool _during_initial_mark; - bool _mark_in_progress; public: G1ParClosureSuper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state); bool apply_to_weak_ref_discovered_field() { return true; } @@ -133,23 +129,10 @@ // Add back base class for metadata class G1ParCopyHelper : public G1ParClosureSuper { +protected: Klass* _scanned_klass; - - public: - G1ParCopyHelper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) : - _scanned_klass(NULL), - G1ParClosureSuper(g1, par_scan_state) {} + ConcurrentMark* _cm; - void set_scanned_klass(Klass* k) { _scanned_klass = k; } - template <class T> void do_klass_barrier(T* p, oop new_obj); -}; - -template <G1Barrier barrier, bool do_mark_object> -class G1ParCopyClosure : public G1ParCopyHelper { - G1ParScanClosure _scanner; - template <class T> void do_oop_work(T* p); - -protected: // Mark the object if it's not already marked. This is used to mark // objects pointed to by roots that are guaranteed not to move // during the GC (i.e., non-CSet objects). It is MT-safe. @@ -159,22 +142,26 @@ // objects pointed to by roots that have been forwarded during a // GC. It is MT-safe. void mark_forwarded_object(oop from_obj, oop to_obj); + public: + G1ParCopyHelper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state); - oop copy_to_survivor_space(oop obj); + void set_scanned_klass(Klass* k) { _scanned_klass = k; } + template <class T> void do_klass_barrier(T* p, oop new_obj); +}; + +template <G1Barrier barrier, bool do_mark_object> +class G1ParCopyClosure : public G1ParCopyHelper { +private: + template <class T> void do_oop_work(T* p); public: G1ParCopyClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state, ReferenceProcessor* rp) : - _scanner(g1, par_scan_state, rp), G1ParCopyHelper(g1, par_scan_state) { assert(_ref_processor == NULL, "sanity"); } - G1ParScanClosure* scanner() { return &_scanner; } - - template <class T> void do_oop_nv(T* p) { - do_oop_work(p); - } + template <class T> void do_oop_nv(T* p) { do_oop_work(p); } virtual void do_oop(oop* p) { do_oop_nv(p); } virtual void do_oop(narrowOop* p) { do_oop_nv(p); } };
--- a/src/share/vm/gc_implementation/g1/g1OopClosures.inline.hpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/gc_implementation/g1/g1OopClosures.inline.hpp Fri Feb 28 08:02:20 2014 -0800 @@ -83,7 +83,7 @@ _par_scan_state->push_on_queue(p); } else { - _par_scan_state->update_rs(_from, p, _par_scan_state->queue_num()); + _par_scan_state->update_rs(_from, p, _worker_id); } } }
--- a/src/share/vm/gc_implementation/parallelScavenge/psTasks.cpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/gc_implementation/parallelScavenge/psTasks.cpp Fri Feb 28 08:02:20 2014 -0800 @@ -65,7 +65,7 @@ case threads: { ResourceMark rm; - CLDToOopClosure* cld_closure = NULL; // Not needed. All CLDs are already visited. + CLDClosure* cld_closure = NULL; // Not needed. All CLDs are already visited. Threads::oops_do(&roots_closure, cld_closure, NULL); } break; @@ -122,7 +122,7 @@ PSPromotionManager* pm = PSPromotionManager::gc_thread_promotion_manager(which); PSScavengeRootsClosure roots_closure(pm); - CLDToOopClosure* roots_from_clds = NULL; // Not needed. All CLDs are already visited. + CLDClosure* roots_from_clds = NULL; // Not needed. All CLDs are already visited. CodeBlobToOopClosure roots_in_blobs(&roots_closure, /*do_marking=*/ true); if (_java_thread != NULL)
--- a/src/share/vm/gc_implementation/shared/parGCAllocBuffer.hpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/gc_implementation/shared/parGCAllocBuffer.hpp Fri Feb 28 08:02:20 2014 -0800 @@ -158,7 +158,7 @@ // Fills in the unallocated portion of the buffer with a garbage object. // If "end_of_gc" is TRUE, is after the last use in the GC. IF "retain" // is true, attempt to re-use the unused portion in the next GC. - virtual void retire(bool end_of_gc, bool retain); + void retire(bool end_of_gc, bool retain); void print() PRODUCT_RETURN; };
--- a/src/share/vm/memory/iterator.hpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/memory/iterator.hpp Fri Feb 28 08:02:20 2014 -0800 @@ -128,6 +128,11 @@ virtual void do_klass(Klass* k) = 0; }; +class CLDClosure : public Closure { + public: + virtual void do_cld(ClassLoaderData* cld) = 0; +}; + class KlassToOopClosure : public KlassClosure { OopClosure* _oop_closure; public: @@ -135,7 +140,7 @@ virtual void do_klass(Klass* k); }; -class CLDToOopClosure { +class CLDToOopClosure : public CLDClosure { OopClosure* _oop_closure; KlassToOopClosure _klass_closure; bool _must_claim_cld;
--- a/src/share/vm/oops/instanceKlass.cpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/oops/instanceKlass.cpp Fri Feb 28 08:02:20 2014 -0800 @@ -49,6 +49,7 @@ #include "prims/jvmtiExport.hpp" #include "prims/jvmtiRedefineClassesTrace.hpp" #include "prims/jvmtiRedefineClasses.hpp" +#include "prims/jvmtiThreadState.hpp" #include "prims/methodComparator.hpp" #include "runtime/fieldDescriptor.hpp" #include "runtime/handles.inline.hpp" @@ -862,10 +863,16 @@ // Step 10 and 11 Handle e(THREAD, PENDING_EXCEPTION); CLEAR_PENDING_EXCEPTION; + // JVMTI has already reported the pending exception + // JVMTI internal flag reset is needed in order to report ExceptionInInitializerError + JvmtiExport::clear_detected_exception((JavaThread*)THREAD); { EXCEPTION_MARK; this_oop->set_initialization_state_and_notify(initialization_error, THREAD); CLEAR_PENDING_EXCEPTION; // ignore any exception thrown, class initialization error is thrown below + // JVMTI has already reported the pending exception + // JVMTI internal flag reset is needed in order to report ExceptionInInitializerError + JvmtiExport::clear_detected_exception((JavaThread*)THREAD); } DTRACE_CLASSINIT_PROBE_WAIT(error, InstanceKlass::cast(this_oop()), -1,wait); if (e->is_a(SystemDictionary::Error_klass())) { @@ -2981,8 +2988,7 @@ offset <= (juint) value->length() && offset + length <= (juint) value->length()) { st->print(BULLET"string: "); - Handle h_obj(obj); - java_lang_String::print(h_obj, st); + java_lang_String::print(obj, st); st->cr(); if (!WizardMode) return; // that is enough }
--- a/src/share/vm/oops/klass.cpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/oops/klass.cpp Fri Feb 28 08:02:20 2014 -0800 @@ -692,3 +692,21 @@ } #endif + +/////////////// Unit tests /////////////// + +#ifndef PRODUCT + +class TestKlass { + public: + static void test_oop_is_instanceClassLoader() { + assert(SystemDictionary::ClassLoader_klass()->oop_is_instanceClassLoader(), "assert"); + assert(!SystemDictionary::String_klass()->oop_is_instanceClassLoader(), "assert"); + } +}; + +void TestKlass_test() { + TestKlass::test_oop_is_instanceClassLoader(); +} + +#endif
--- a/src/share/vm/oops/klass.hpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/oops/klass.hpp Fri Feb 28 08:02:20 2014 -0800 @@ -498,6 +498,7 @@ virtual bool oop_is_objArray_slow() const { return false; } virtual bool oop_is_typeArray_slow() const { return false; } public: + virtual bool oop_is_instanceClassLoader() const { return false; } virtual bool oop_is_instanceMirror() const { return false; } virtual bool oop_is_instanceRef() const { return false; }
--- a/src/share/vm/oops/oop.hpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/oops/oop.hpp Fri Feb 28 08:02:20 2014 -0800 @@ -109,12 +109,13 @@ int size_given_klass(Klass* klass); // type test operations (inlined in oop.inline.h) - bool is_instance() const; - bool is_instanceMirror() const; - bool is_instanceRef() const; - bool is_array() const; - bool is_objArray() const; - bool is_typeArray() const; + bool is_instance() const; + bool is_instanceMirror() const; + bool is_instanceClassLoader() const; + bool is_instanceRef() const; + bool is_array() const; + bool is_objArray() const; + bool is_typeArray() const; private: // field addresses in oop
--- a/src/share/vm/oops/oop.inline.hpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/oops/oop.inline.hpp Fri Feb 28 08:02:20 2014 -0800 @@ -147,12 +147,13 @@ inline bool oopDesc::is_a(Klass* k) const { return klass()->is_subtype_of(k); } -inline bool oopDesc::is_instance() const { return klass()->oop_is_instance(); } -inline bool oopDesc::is_instanceMirror() const { return klass()->oop_is_instanceMirror(); } -inline bool oopDesc::is_instanceRef() const { return klass()->oop_is_instanceRef(); } -inline bool oopDesc::is_array() const { return klass()->oop_is_array(); } -inline bool oopDesc::is_objArray() const { return klass()->oop_is_objArray(); } -inline bool oopDesc::is_typeArray() const { return klass()->oop_is_typeArray(); } +inline bool oopDesc::is_instance() const { return klass()->oop_is_instance(); } +inline bool oopDesc::is_instanceClassLoader() const { return klass()->oop_is_instanceClassLoader(); } +inline bool oopDesc::is_instanceMirror() const { return klass()->oop_is_instanceMirror(); } +inline bool oopDesc::is_instanceRef() const { return klass()->oop_is_instanceRef(); } +inline bool oopDesc::is_array() const { return klass()->oop_is_array(); } +inline bool oopDesc::is_objArray() const { return klass()->oop_is_objArray(); } +inline bool oopDesc::is_typeArray() const { return klass()->oop_is_typeArray(); } inline void* oopDesc::field_base(int offset) const { return (void*)&((char*)this)[offset]; }
--- a/src/share/vm/opto/c2compiler.cpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/opto/c2compiler.cpp Fri Feb 28 08:02:20 2014 -0800 @@ -114,7 +114,7 @@ assert(is_initialized(), "Compiler thread must be initialized"); bool subsume_loads = SubsumeLoads; - bool do_escape_analysis = DoEscapeAnalysis && !env->jvmti_can_access_local_variables(); + bool do_escape_analysis = DoEscapeAnalysis && !env->should_retain_local_variables(); bool eliminate_boxing = EliminateAutoBox; while (!env->failing()) { // Attempt to compile while subsuming loads into machine instructions.
--- a/src/share/vm/opto/graphKit.cpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/opto/graphKit.cpp Fri Feb 28 08:02:20 2014 -0800 @@ -865,7 +865,7 @@ } } - if (env()->jvmti_can_access_local_variables()) { + if (env()->should_retain_local_variables()) { // At any safepoint, this method can get breakpointed, which would // then require an immediate deoptimization. can_prune_locals = false; // do not prune locals
--- a/src/share/vm/prims/jni.cpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/prims/jni.cpp Fri Feb 28 08:02:20 2014 -0800 @@ -3876,9 +3876,10 @@ void TestMetaspaceAux_test(); void TestMetachunk_test(); void TestVirtualSpaceNode_test(); +void TestNewSize_test(); +void TestKlass_test(); +#if INCLUDE_ALL_GCS void TestOldFreeSpaceCalculation_test(); -void TestNewSize_test(); -#if INCLUDE_ALL_GCS void TestG1BiasedArray_test(); void TestBufferingOopClosure_test(); #endif @@ -3899,12 +3900,13 @@ run_unit_test(QuickSort::test_quick_sort()); run_unit_test(AltHashing::test_alt_hash()); run_unit_test(test_loggc_filename()); - run_unit_test(TestOldFreeSpaceCalculation_test()); run_unit_test(TestNewSize_test()); + run_unit_test(TestKlass_test()); #if INCLUDE_VM_STRUCTS run_unit_test(VMStructs::test()); #endif #if INCLUDE_ALL_GCS + run_unit_test(TestOldFreeSpaceCalculation_test()); run_unit_test(TestG1BiasedArray_test()); run_unit_test(HeapRegionRemSet::test_prt()); run_unit_test(TestBufferingOopClosure_test());
--- a/src/share/vm/prims/jvm.cpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/prims/jvm.cpp Fri Feb 28 08:02:20 2014 -0800 @@ -1241,7 +1241,11 @@ if (HAS_PENDING_EXCEPTION) { pending_exception = Handle(THREAD, PENDING_EXCEPTION); CLEAR_PENDING_EXCEPTION; - + // JVMTI has already reported the pending exception + // JVMTI internal flag reset is needed in order to report PrivilegedActionException + if (THREAD->is_Java_thread()) { + JvmtiExport::clear_detected_exception((JavaThread*) THREAD); + } if ( pending_exception->is_a(SystemDictionary::Exception_klass()) && !pending_exception->is_a(SystemDictionary::RuntimeException_klass())) { // Throw a java.security.PrivilegedActionException(Exception e) exception
--- a/src/share/vm/prims/jvmtiExport.cpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/prims/jvmtiExport.cpp Fri Feb 28 08:02:20 2014 -0800 @@ -2161,6 +2161,15 @@ } } +void JvmtiExport::clear_detected_exception(JavaThread* thread) { + assert(JavaThread::current() == thread, "thread is not current"); + + JvmtiThreadState* state = thread->jvmti_thread_state(); + if (state != NULL) { + state->clear_exception_detected(); + } +} + void JvmtiExport::oops_do(OopClosure* f) { JvmtiCurrentBreakpoints::oops_do(f); JvmtiVMObjectAllocEventCollector::oops_do_for_all_threads(f);
--- a/src/share/vm/prims/jvmtiExport.hpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/prims/jvmtiExport.hpp Fri Feb 28 08:02:20 2014 -0800 @@ -363,6 +363,7 @@ } static void cleanup_thread (JavaThread* thread) NOT_JVMTI_RETURN; + static void clear_detected_exception (JavaThread* thread) NOT_JVMTI_RETURN; static void oops_do(OopClosure* f) NOT_JVMTI_RETURN; static void weak_oops_do(BoolObjectClosure* b, OopClosure* f) NOT_JVMTI_RETURN;
--- a/src/share/vm/prims/jvmtiTagMap.cpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/prims/jvmtiTagMap.cpp Fri Feb 28 08:02:20 2014 -0800 @@ -3081,6 +3081,23 @@ } } } + + StackValueCollection* exprs = jvf->expressions(); + for (int index=0; index < exprs->size(); index++) { + if (exprs->at(index)->type() == T_OBJECT) { + oop o = exprs->obj_at(index)(); + if (o == NULL) { + continue; + } + + // stack reference + if (!CallbackInvoker::report_stack_ref_root(thread_tag, tid, depth, method, + bci, locals->size() + index, o)) { + return false; + } + } + } + } else { blk->set_context(thread_tag, tid, depth, method); if (is_top_frame) {
--- a/src/share/vm/runtime/arguments.cpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/runtime/arguments.cpp Fri Feb 28 08:02:20 2014 -0800 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -1661,6 +1661,9 @@ return result; } +// Use static initialization to get the default before parsing +static const uintx DefaultHeapBaseMinAddress = HeapBaseMinAddress; + void Arguments::set_heap_size() { if (!FLAG_IS_DEFAULT(DefaultMaxRAMFraction)) { // Deprecated flag @@ -1692,6 +1695,23 @@ if (UseCompressedOops) { // Limit the heap size to the maximum possible when using compressed oops julong max_coop_heap = (julong)max_heap_for_compressed_oops(); + + // HeapBaseMinAddress can be greater than default but not less than. + if (!FLAG_IS_DEFAULT(HeapBaseMinAddress)) { + if (HeapBaseMinAddress < DefaultHeapBaseMinAddress) { + if (PrintMiscellaneous && Verbose) { // matches compressed oops printing flags + jio_fprintf(defaultStream::error_stream(), + "HeapBaseMinAddress must be at least " UINTX_FORMAT + " (" UINTX_FORMAT "G) which is greater than value given " + UINTX_FORMAT "\n", + DefaultHeapBaseMinAddress, + DefaultHeapBaseMinAddress/G, + HeapBaseMinAddress); + } + FLAG_SET_ERGO(uintx, HeapBaseMinAddress, DefaultHeapBaseMinAddress); + } + } + if (HeapBaseMinAddress + MaxHeapSize < max_coop_heap) { // Heap should be above HeapBaseMinAddress to get zero based compressed oops // but it should be not less than default MaxHeapSize.
--- a/src/share/vm/runtime/frame.cpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/runtime/frame.cpp Fri Feb 28 08:02:20 2014 -0800 @@ -895,7 +895,7 @@ } -void frame::oops_interpreted_do(OopClosure* f, CLDToOopClosure* cld_f, +void frame::oops_interpreted_do(OopClosure* f, CLDClosure* cld_f, const RegisterMap* map, bool query_oop_map_cache) { assert(is_interpreted_frame(), "Not an interpreted frame"); assert(map != NULL, "map must be set"); @@ -1135,7 +1135,7 @@ } -void frame::oops_do_internal(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf, RegisterMap* map, bool use_interpreter_oop_map_cache) { +void frame::oops_do_internal(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf, RegisterMap* map, bool use_interpreter_oop_map_cache) { #ifndef PRODUCT // simulate GC crash here to dump java thread in error report if (CrashGCForDumpingJavaThread) {
--- a/src/share/vm/runtime/frame.hpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/runtime/frame.hpp Fri Feb 28 08:02:20 2014 -0800 @@ -419,19 +419,19 @@ // Oops-do's void oops_compiled_arguments_do(Symbol* signature, bool has_receiver, bool has_appendix, const RegisterMap* reg_map, OopClosure* f); - void oops_interpreted_do(OopClosure* f, CLDToOopClosure* cld_f, const RegisterMap* map, bool query_oop_map_cache = true); + void oops_interpreted_do(OopClosure* f, CLDClosure* cld_f, const RegisterMap* map, bool query_oop_map_cache = true); private: void oops_interpreted_arguments_do(Symbol* signature, bool has_receiver, OopClosure* f); // Iteration of oops - void oops_do_internal(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf, RegisterMap* map, bool use_interpreter_oop_map_cache); + void oops_do_internal(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf, RegisterMap* map, bool use_interpreter_oop_map_cache); void oops_entry_do(OopClosure* f, const RegisterMap* map); void oops_code_blob_do(OopClosure* f, CodeBlobClosure* cf, const RegisterMap* map); int adjust_offset(Method* method, int index); // helper for above fn public: // Memory management - void oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf, RegisterMap* map) { oops_do_internal(f, cld_f, cf, map, true); } + void oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf, RegisterMap* map) { oops_do_internal(f, cld_f, cf, map, true); } void nmethods_do(CodeBlobClosure* cf); // RedefineClasses support for finding live interpreted methods on the stack
--- a/src/share/vm/runtime/os.hpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/runtime/os.hpp Fri Feb 28 08:02:20 2014 -0800 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -165,6 +165,7 @@ static jlong javaTimeNanos(); static void javaTimeNanos_info(jvmtiTimerInfo *info_ptr); static void run_periodic_checks(); + static bool supports_monotonic_clock(); // Returns the elapsed time in seconds since the vm started.
--- a/src/share/vm/runtime/reflection.cpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/runtime/reflection.cpp Fri Feb 28 08:02:20 2014 -0800 @@ -36,6 +36,7 @@ #include "oops/objArrayKlass.hpp" #include "oops/objArrayOop.hpp" #include "prims/jvm.h" +#include "prims/jvmtiExport.hpp" #include "runtime/arguments.hpp" #include "runtime/handles.inline.hpp" #include "runtime/javaCalls.hpp" @@ -941,6 +942,11 @@ // Method resolution threw an exception; wrap it in an InvocationTargetException oop resolution_exception = PENDING_EXCEPTION; CLEAR_PENDING_EXCEPTION; + // JVMTI has already reported the pending exception + // JVMTI internal flag reset is needed in order to report InvocationTargetException + if (THREAD->is_Java_thread()) { + JvmtiExport::clear_detected_exception((JavaThread*) THREAD); + } JavaCallArguments args(Handle(THREAD, resolution_exception)); THROW_ARG_0(vmSymbols::java_lang_reflect_InvocationTargetException(), vmSymbols::throwable_void_signature(), @@ -1073,6 +1079,12 @@ // Method threw an exception; wrap it in an InvocationTargetException oop target_exception = PENDING_EXCEPTION; CLEAR_PENDING_EXCEPTION; + // JVMTI has already reported the pending exception + // JVMTI internal flag reset is needed in order to report InvocationTargetException + if (THREAD->is_Java_thread()) { + JvmtiExport::clear_detected_exception((JavaThread*) THREAD); + } + JavaCallArguments args(Handle(THREAD, target_exception)); THROW_ARG_0(vmSymbols::java_lang_reflect_InvocationTargetException(), vmSymbols::throwable_void_signature(),
--- a/src/share/vm/runtime/thread.cpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/runtime/thread.cpp Fri Feb 28 08:02:20 2014 -0800 @@ -804,7 +804,7 @@ return false; } -void Thread::oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf) { +void Thread::oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf) { active_handles()->oops_do(f); // Do oop for ThreadShadow f->do_oop((oop*)&_pending_exception); @@ -2700,7 +2700,7 @@ } }; -void JavaThread::oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf) { +void JavaThread::oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf) { // Verify that the deferred card marks have been flushed. assert(deferred_card_mark().is_empty(), "Should be empty during GC"); @@ -3223,7 +3223,7 @@ #endif } -void CompilerThread::oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf) { +void CompilerThread::oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf) { JavaThread::oops_do(f, cld_f, cf); if (_scanned_nmethod != NULL && cf != NULL) { // Safepoints can occur when the sweeper is scanning an nmethod so @@ -4111,14 +4111,14 @@ // uses the Threads_lock to guarantee this property. It also makes sure that // all threads gets blocked when exiting or starting). -void Threads::oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf) { +void Threads::oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf) { ALL_JAVA_THREADS(p) { p->oops_do(f, cld_f, cf); } VMThread::vm_thread()->oops_do(f, cld_f, cf); } -void Threads::possibly_parallel_oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf) { +void Threads::possibly_parallel_oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf) { // Introduce a mechanism allowing parallel threads to claim threads as // root groups. Overhead should be small enough to use all the time, // even in sequential code.
--- a/src/share/vm/runtime/thread.hpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/runtime/thread.hpp Fri Feb 28 08:02:20 2014 -0800 @@ -487,7 +487,7 @@ // Apply "cld_f->do_cld" to CLDs that are otherwise not kept alive. // Used by JavaThread::oops_do. // Apply "cf->do_code_blob" (if !NULL) to all code blobs active in frames - virtual void oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf); + virtual void oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf); // Handles the parallel case for the method below. private: @@ -1448,7 +1448,7 @@ void frames_do(void f(frame*, const RegisterMap*)); // Memory operations - void oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf); + void oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf); // Sweeper operations void nmethods_do(CodeBlobClosure* cf); @@ -1879,7 +1879,7 @@ // GC support // Apply "f->do_oop" to all root oops in "this". // Apply "cf->do_code_blob" (if !NULL) to all code blobs active in frames - void oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf); + void oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf); #ifndef PRODUCT private: @@ -1948,9 +1948,9 @@ // Apply "f->do_oop" to all root oops in all threads. // This version may only be called by sequential code. - static void oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf); + static void oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf); // This version may be called by sequential or parallel code. - static void possibly_parallel_oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf); + static void possibly_parallel_oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf); // This creates a list of GCTasks, one per thread. static void create_thread_roots_tasks(GCTaskQueue* q); // This creates a list of GCTasks, one per thread, for marking objects.
--- a/src/share/vm/runtime/vmThread.cpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/runtime/vmThread.cpp Fri Feb 28 08:02:20 2014 -0800 @@ -656,7 +656,7 @@ } -void VMThread::oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf) { +void VMThread::oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf) { Thread::oops_do(f, cld_f, cf); _vm_queue->oops_do(f); }
--- a/src/share/vm/runtime/vmThread.hpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/runtime/vmThread.hpp Fri Feb 28 08:02:20 2014 -0800 @@ -126,7 +126,7 @@ static VMThread* vm_thread() { return _vm_thread; } // GC support - void oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf); + void oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf); // Debugging void print_on(outputStream* st) const;
--- a/src/share/vm/services/heapDumper.cpp Fri Feb 28 13:44:16 2014 +0100 +++ b/src/share/vm/services/heapDumper.cpp Fri Feb 28 08:02:20 2014 -0800 @@ -1604,6 +1604,18 @@ } } } + StackValueCollection *exprs = jvf->expressions(); + for(int index = 0; index < exprs->size(); index++) { + if (exprs->at(index)->type() == T_OBJECT) { + oop o = exprs->obj_at(index)(); + if (o != NULL) { + writer()->write_u1(HPROF_GC_ROOT_JAVA_FRAME); + writer()->write_objectID(o); + writer()->write_u4(thread_serial_num); + writer()->write_u4((u4) (stack_depth + extra_frames)); + } + } + } } else { // native frame if (stack_depth == 0) {
--- a/test/TEST.groups Fri Feb 28 13:44:16 2014 +0100 +++ b/test/TEST.groups Fri Feb 28 08:02:20 2014 -0800 @@ -67,10 +67,8 @@ gc/metaspace/TestPerfCountersAndMemoryPools.java \ runtime/6819213/TestBootNativeLibraryPath.java \ runtime/6925573/SortMethodsTest.java \ - runtime/7107135/Test7107135.sh \ runtime/7158988/FieldMonitor.java \ runtime/7194254/Test7194254.java \ - runtime/jsig/Test8017498.sh \ runtime/Metaspace/FragmentMetaspace.java \ runtime/NMT/BaselineWithParameter.java \ runtime/NMT/JcmdScale.java \ @@ -175,7 +173,6 @@ gc/startup_warnings/TestParallelScavengeSerialOld.java \ gc/startup_warnings/TestParNewCMS.java \ gc/startup_warnings/TestParNewSerialOld.java \ - runtime/6929067/Test6929067.sh \ runtime/SharedArchiveFile/SharedArchiveFile.java # Minimal VM on Compact 2 adds in some compact2 tests
--- a/test/runtime/6925573/SortMethodsTest.java Fri Feb 28 13:44:16 2014 +0100 +++ b/test/runtime/6925573/SortMethodsTest.java Fri Feb 28 08:02:20 2014 -0800 @@ -47,6 +47,7 @@ import javax.tools.ToolProvider; /* + * @ignore 6959423 * @test SortMethodsTest * @bug 6925573 * @summary verify that class loading does not need quadratic time with regard to the number of class
--- a/test/runtime/6929067/Test6929067.sh Fri Feb 28 13:44:16 2014 +0100 +++ b/test/runtime/6929067/Test6929067.sh Fri Feb 28 08:02:20 2014 -0800 @@ -4,6 +4,7 @@ ## @test Test6929067.sh ## @bug 6929067 ## @bug 8021296 +## @bug 8025519 ## @summary Stack guard pages should be removed when thread is detached ## @run shell Test6929067.sh ## @@ -113,7 +114,7 @@ export LD_LIBRARY_PATH cp ${TESTSRC}${FS}*.java ${THIS_DIR} -${TESTJAVA}${FS}bin${FS}javac *.java +${COMPILEJAVA}${FS}bin${FS}javac *.java echo "Architecture: ${ARCH}" echo "Compilation flag: ${COMP_FLAG}" @@ -123,8 +124,8 @@ # for /usr/lib/`uname -m`-linux-gnu version ensure to add that path to below compilation. $gcc_cmd -DLINUX ${COMP_FLAG} -o invoke \ - -I${TESTJAVA}/include -I${TESTJAVA}/include/linux \ - -L${TESTJAVA}/jre/lib/${ARCH}/${VMTYPE} \ + -I${COMPILEJAVA}/include -I${COMPILEJAVA}/include/linux \ + -L${COMPILEJAVA}/jre/lib/${ARCH}/${VMTYPE} \ ${TESTSRC}${FS}invoke.c -ljvm -lpthread ./invoke
--- a/test/runtime/7107135/Test7107135.sh Fri Feb 28 13:44:16 2014 +0100 +++ b/test/runtime/7107135/Test7107135.sh Fri Feb 28 08:02:20 2014 -0800 @@ -1,7 +1,7 @@ #!/bin/sh # -# Copyright (c) 1998, 2013, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 1998, 2014, Oracle and/or its affiliates. All rights reserved. # Copyright (c) 2011 SAP AG. All Rights Reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # @@ -25,9 +25,11 @@ # ## +## @ignore 8025519 ## @test Test7107135.sh ## @bug 7107135 ## @bug 8021296 +## @bug 8025519 ## @summary Stack guard pages lost after loading library with executable stack. ## @run shell Test7107135.sh ## @@ -63,10 +65,10 @@ THIS_DIR=. cp ${TESTSRC}${FS}*.java ${THIS_DIR} -${TESTJAVA}${FS}bin${FS}javac *.java +${COMPILEJAVA}${FS}bin${FS}javac *.java $gcc_cmd -fPIC -shared -c -o test.o \ - -I${TESTJAVA}${FS}include -I${TESTJAVA}${FS}include${FS}linux \ + -I${COMPILEJAVA}${FS}include -I${COMPILEJAVA}${FS}include${FS}linux \ ${TESTSRC}${FS}test.c ld -shared -z execstack -o libtest-rwx.so test.o
--- a/test/runtime/CompressedOops/CompressedClassPointers.java Fri Feb 28 13:44:16 2014 +0100 +++ b/test/runtime/CompressedOops/CompressedClassPointers.java Fri Feb 28 08:02:20 2014 -0800 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2013, 2014, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -80,6 +80,18 @@ output.shouldHaveExitValue(0); } + public static void heapBaseMinAddressTest() throws Exception { + ProcessBuilder pb = ProcessTools.createJavaProcessBuilder( + "-XX:HeapBaseMinAddress=1m", + "-XX:+PrintMiscellaneous", + "-XX:+Verbose", + "-version"); + OutputAnalyzer output = new OutputAnalyzer(pb.start()); + output.shouldContain("HeapBaseMinAddress must be at least"); + output.shouldContain("HotSpot"); + output.shouldHaveExitValue(0); + } + public static void sharingTest() throws Exception { // Test small heaps ProcessBuilder pb = ProcessTools.createJavaProcessBuilder( @@ -113,24 +125,25 @@ } } - public static void main(String[] args) throws Exception { - if (!Platform.is64bit()) { - // Can't test this on 32 bit, just pass - System.out.println("Skipping test on 32bit"); - return; - } - // Solaris 10 can't mmap compressed oops space without a base - if (Platform.isSolaris()) { - String name = System.getProperty("os.version"); - if (name.equals("5.10")) { - System.out.println("Skipping test on Solaris 10"); - return; - } - } - smallHeapTest(); - smallHeapTestWith3G(); - largeHeapTest(); - largePagesTest(); - sharingTest(); - } + public static void main(String[] args) throws Exception { + if (!Platform.is64bit()) { + // Can't test this on 32 bit, just pass + System.out.println("Skipping test on 32bit"); + return; + } + // Solaris 10 can't mmap compressed oops space without a base + if (Platform.isSolaris()) { + String name = System.getProperty("os.version"); + if (name.equals("5.10")) { + System.out.println("Skipping test on Solaris 10"); + return; + } + } + smallHeapTest(); + smallHeapTestWith3G(); + largeHeapTest(); + largePagesTest(); + heapBaseMinAddressTest(); + sharingTest(); + } }
--- a/test/runtime/SharedArchiveFile/CdsDifferentObjectAlignment.java Fri Feb 28 13:44:16 2014 +0100 +++ b/test/runtime/SharedArchiveFile/CdsDifferentObjectAlignment.java Fri Feb 28 08:02:20 2014 -0800 @@ -22,6 +22,7 @@ */ /* + * @ignore 8025642 * @test CdsDifferentObjectAlignment * @summary Testing CDS (class data sharing) using varying object alignment. * Using different object alignment for each dump/load pair. @@ -29,6 +30,7 @@ * is different from object alignment for creating a CDS file * should fail when loading. * @library /testlibrary + * @bug 8025642 */ import com.oracle.java.testlibrary.*;
--- a/test/runtime/SharedArchiveFile/CdsWriteError.java Fri Feb 28 13:44:16 2014 +0100 +++ b/test/runtime/SharedArchiveFile/CdsWriteError.java Fri Feb 28 08:02:20 2014 -0800 @@ -22,12 +22,14 @@ */ /* + * @ignore 8032222 * @test CdsWriteError * @summary Test how VM handles situation when it is impossible to write the * CDS archive. VM is expected to exit gracefully and display the * correct reason for the error. * @library /testlibrary * @run main CdsWriteError + * @bug 8032222 */ import com.oracle.java.testlibrary.*;
--- a/test/runtime/SharedArchiveFile/DefaultUseWithClient.java Fri Feb 28 13:44:16 2014 +0100 +++ b/test/runtime/SharedArchiveFile/DefaultUseWithClient.java Fri Feb 28 08:02:20 2014 -0800 @@ -22,10 +22,12 @@ */ /* + * @ignore 8032224 * @test DefaultUseWithClient * @summary Test default behavior of sharing with -client * @library /testlibrary * @run main DefaultUseWithClient + * @bug 8032224 */ import com.oracle.java.testlibrary.*;
--- a/test/runtime/jsig/Test8017498.sh Fri Feb 28 13:44:16 2014 +0100 +++ b/test/runtime/jsig/Test8017498.sh Fri Feb 28 08:02:20 2014 -0800 @@ -30,8 +30,9 @@ ## @bug 8020791 ## @bug 8021296 ## @bug 8022301 +## @bug 8025519 ## @summary sigaction(sig) results in process hang/timed-out if sig is much greater than SIGRTMAX -## @run shell/timeout=30 Test8017498.sh +## @run shell/timeout=60 Test8017498.sh ## if [ "${TESTSRC}" = "" ] @@ -55,12 +56,9 @@ echo "WARNING: gcc not found. Cannot execute test." 2>&1 exit 0; fi - if [ "$VM_BITS" = "64" ] - then - MY_LD_PRELOAD=${TESTJAVA}${FS}jre${FS}lib${FS}amd64${FS}libjsig.so - else - MY_LD_PRELOAD=${TESTJAVA}${FS}jre${FS}lib${FS}i386${FS}libjsig.so - EXTRA_CFLAG=-m32 + MY_LD_PRELOAD=${TESTJAVA}${FS}jre${FS}lib${FS}${VM_CPU}${FS}libjsig.so + if [ "$VM_BITS" == "32" ] && [ "$VM_CPU" != "arm" ] && [ "$VM_CPU" != "ppc" ]; then + EXTRA_CFLAG=-m32 fi echo MY_LD_PRELOAD = ${MY_LD_PRELOAD} ;; @@ -73,13 +71,13 @@ THIS_DIR=. cp ${TESTSRC}${FS}*.java ${THIS_DIR} -${TESTJAVA}${FS}bin${FS}javac *.java +${COMPILEJAVA}${FS}bin${FS}javac *.java $gcc_cmd -DLINUX -fPIC -shared \ ${EXTRA_CFLAG} -z noexecstack \ -o ${TESTSRC}${FS}libTestJNI.so \ - -I${TESTJAVA}${FS}include \ - -I${TESTJAVA}${FS}include${FS}linux \ + -I${COMPILEJAVA}${FS}include \ + -I${COMPILEJAVA}${FS}include${FS}linux \ ${TESTSRC}${FS}TestJNI.c # run the java test in the background