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

equal deleted inserted replaced

-:511dd7b5313b
+:76dbe86f3d82
 #include "runtime/osThread.hpp"
 #include "runtime/stubRoutines.hpp"
 #include "runtime/synchronizer.hpp"
 #include "runtime/thread.inline.hpp"
 #include "runtime/vframe.hpp"
+#include "trace/traceMacros.hpp"
+#include "trace/tracing.hpp"
 #include "utilities/dtrace.hpp"
 #include "utilities/events.hpp"
 #include "utilities/preserveException.hpp"
 #if defined(__GNUC__) && !defined(PPC64)
 int ObjectSynchronizer::gOmInUseCount = 0;
 static volatile intptr_t gListLock = 0;      // protects global monitor lists
 static volatile int gMonitorFreeCount  = 0;  // # on gFreeList
 static volatile int gMonitorPopulation = 0;  // # Extant -- in circulation
+static void post_monitor_inflate_event(EventJavaMonitorInflate&,
+const oop,
+const ObjectSynchronizer::InflateCause);
 #define CHAINMARKER (cast_to_oop<intptr_t>(-1))
 // =====================> Quick functions
 TEVENT(fast_exit: release stacklock);
 return;
 }
 }
-ObjectSynchronizer::inflate(THREAD, object)->exit(true, THREAD);
+ObjectSynchronizer::inflate(THREAD,
+object,
+inflate_cause_vm_internal)->exit(true, THREAD);
 }
 // -----------------------------------------------------------------------------
 // Interpreter/Compiler Slow Case
 // This routine is used to handle interpreter/compiler slow case
 // The object header will never be displaced to this lock,
 // so it does not matter what the value is, except that it
 // must be non-zero to avoid looking like a re-entrant lock,
 // and must not look locked either.
 lock->set_displaced_header(markOopDesc::unused_mark());
-ObjectSynchronizer::inflate(THREAD, obj())->enter(THREAD);
+ObjectSynchronizer::inflate(THREAD,
+obj(),
+inflate_cause_monitor_enter)->enter(THREAD);
 }
 // This routine is used to handle interpreter/compiler slow case
 // We don't need to use fast path here, because it must have
 // failed in the interpreter/compiler code. Simply use the heavy
 if (UseBiasedLocking) {
 BiasedLocking::revoke_and_rebias(obj, false, THREAD);
 assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
 }
-ObjectMonitor* monitor = ObjectSynchronizer::inflate(THREAD, obj());
+ObjectMonitor* monitor = ObjectSynchronizer::inflate(THREAD,
+obj(),
+inflate_cause_vm_internal);
 return monitor->complete_exit(THREAD);
 }
 // NOTE: must use heavy weight monitor to handle complete_exit/reenter()
 if (UseBiasedLocking) {
 BiasedLocking::revoke_and_rebias(obj, false, THREAD);
 assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
 }
-ObjectMonitor* monitor = ObjectSynchronizer::inflate(THREAD, obj());
+ObjectMonitor* monitor = ObjectSynchronizer::inflate(THREAD,
+obj(),
+inflate_cause_vm_internal);
 monitor->reenter(recursion, THREAD);
 }
 // -----------------------------------------------------------------------------
 // JNI locks on java objects
 if (UseBiasedLocking) {
 BiasedLocking::revoke_and_rebias(obj, false, THREAD);
 assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
 }
 THREAD->set_current_pending_monitor_is_from_java(false);
-ObjectSynchronizer::inflate(THREAD, obj())->enter(THREAD);
+ObjectSynchronizer::inflate(THREAD, obj(), inflate_cause_jni_enter)->enter(THREAD);
 THREAD->set_current_pending_monitor_is_from_java(true);
 }
 // NOTE: must use heavy weight monitor to handle jni monitor exit
 void ObjectSynchronizer::jni_exit(oop obj, Thread* THREAD) {
 BiasedLocking::revoke_and_rebias(h_obj, false, THREAD);
 obj = h_obj();
 }
 assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
-ObjectMonitor* monitor = ObjectSynchronizer::inflate(THREAD, obj);
+ObjectMonitor* monitor = ObjectSynchronizer::inflate(THREAD,
+obj,
+inflate_cause_jni_exit);
 // If this thread has locked the object, exit the monitor.  Note:  can't use
 // monitor->check(CHECK); must exit even if an exception is pending.
 if (monitor->check(THREAD)) {
 monitor->exit(true, THREAD);
 }
 }
 if (millis < 0) {
 TEVENT(wait - throw IAX);
 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "timeout value is negative");
 }
-ObjectMonitor* monitor = ObjectSynchronizer::inflate(THREAD, obj());
+ObjectMonitor* monitor = ObjectSynchronizer::inflate(THREAD,
+obj(),
+inflate_cause_wait);
 DTRACE_MONITOR_WAIT_PROBE(monitor, obj(), THREAD, millis);
 monitor->wait(millis, true, THREAD);
 // This dummy call is in place to get around dtrace bug 6254741.  Once
 // that's fixed we can uncomment the following line, remove the call
 }
 if (millis < 0) {
 TEVENT(wait - throw IAX);
 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "timeout value is negative");
 }
-ObjectSynchronizer::inflate(THREAD, obj()) -> wait(millis, false, THREAD);
+ObjectSynchronizer::inflate(THREAD,
+obj(),
+inflate_cause_wait)->wait(millis, false, THREAD);
 }
 void ObjectSynchronizer::notify(Handle obj, TRAPS) {
 if (UseBiasedLocking) {
 BiasedLocking::revoke_and_rebias(obj, false, THREAD);
 markOop mark = obj->mark();
 if (mark->has_locker() && THREAD->is_lock_owned((address)mark->locker())) {
 return;
 }
-ObjectSynchronizer::inflate(THREAD, obj())->notify(THREAD);
+ObjectSynchronizer::inflate(THREAD,
+obj(),
+inflate_cause_notify)->notify(THREAD);
 }
 // NOTE: see comment of notify()
 void ObjectSynchronizer::notifyall(Handle obj, TRAPS) {
 if (UseBiasedLocking) {
 markOop mark = obj->mark();
 if (mark->has_locker() && THREAD->is_lock_owned((address)mark->locker())) {
 return;
 }
-ObjectSynchronizer::inflate(THREAD, obj())->notifyAll(THREAD);
+ObjectSynchronizer::inflate(THREAD,
+obj(),
+inflate_cause_notify)->notifyAll(THREAD);
 }
 // -----------------------------------------------------------------------------
 // Hash Code handling
 //
 // Any change to stack may not propagate to other threads
 // correctly.
 }
 // Inflate the monitor to set hash code
-monitor = ObjectSynchronizer::inflate(Self, obj);
+monitor = ObjectSynchronizer::inflate(Self, obj, inflate_cause_hash_code);
 // Load displaced header and check it has hash code
 mark = monitor->header();
 assert(mark->is_neutral(), "invariant");
 hash = mark->hash();
 if (hash == 0) {
 if (mark->has_monitor()) {
 assert(ObjectSynchronizer::verify_objmon_isinpool(mark->monitor()), "monitor is invalid");
 assert(mark->monitor()->header()->is_neutral(), "monitor must record a good object header");
 return mark->monitor();
 }
-return ObjectSynchronizer::inflate(Thread::current(), obj);
+return ObjectSynchronizer::inflate(Thread::current(),
-}
+obj,
+inflate_cause_vm_internal);
+}
 ObjectMonitor * NOINLINE ObjectSynchronizer::inflate(Thread * Self,
-oop object) {
+oop object,
+const InflateCause cause) {
 // Inflate mutates the heap ...
 // Relaxing assertion for bug 6320749.
 assert(Universe::verify_in_progress() ||
 !SafepointSynchronize::is_at_safepoint(), "invariant");
+EventJavaMonitorInflate event;
 for (;;) {
 const markOop mark = object->mark();
 assert(!mark->has_bias_pattern(), "invariant");
 if (mark->has_monitor()) {
 ObjectMonitor * inf = mark->monitor();
 assert(inf->header()->is_neutral(), "invariant");
 assert(inf->object() == object, "invariant");
 assert(ObjectSynchronizer::verify_objmon_isinpool(inf), "monitor is invalid");
+event.cancel(); // let's not post an inflation event, unless we did the deed ourselves
 return inf;
 }
 // CASE: inflation in progress - inflating over a stack-lock.
 // Some other thread is converting from stack-locked to inflated.
 log_debug(monitorinflation)("Inflating object " INTPTR_FORMAT " , mark " INTPTR_FORMAT " , type %s",
 p2i(object), p2i(object->mark()),
 object->klass()->external_name());
 }
 }
+if (event.should_commit()) {
+post_monitor_inflate_event(event, object, cause);
+}
 return m;
 }
 // CASE: neutral
 // TODO-FIXME: for entry we currently inflate and then try to CAS _owner.
 ResourceMark rm;
 log_debug(monitorinflation)("Inflating object " INTPTR_FORMAT " , mark " INTPTR_FORMAT " , type %s",
 p2i(object), p2i(object->mark()),
 object->klass()->external_name());
 }
+}
+if (event.should_commit()) {
+post_monitor_inflate_event(event, object, cause);
 }
 return m;
 }
 }
 ObjectSynchronizer::monitors_iterate(&rjmc);
 Thread::muxRelease(&gListLock);
 THREAD->clear_pending_exception();
 }
+const char* ObjectSynchronizer::inflate_cause_name(const InflateCause cause) {
+switch (cause) {
+case inflate_cause_vm_internal:    return "VM Internal";
+case inflate_cause_monitor_enter:  return "Monitor Enter";
+case inflate_cause_wait:           return "Monitor Wait";
+case inflate_cause_notify:         return "Monitor Notify";
+case inflate_cause_hash_code:      return "Monitor Hash Code";
+case inflate_cause_jni_enter:      return "JNI Monitor Enter";
+case inflate_cause_jni_exit:       return "JNI Monitor Exit";
+default:
+ShouldNotReachHere();
+}
+return "Unknown";
+}
+static void post_monitor_inflate_event(EventJavaMonitorInflate& event,
+const oop obj,
+const ObjectSynchronizer::InflateCause cause) {
+#if INCLUDE_TRACE
+assert(event.should_commit(), "check outside");
+event.set_klass(obj->klass());
+event.set_address((TYPE_ADDRESS)(uintptr_t)(void*)obj);
+event.set_cause((u1)cause);
+event.commit();
+#endif
+}
 //------------------------------------------------------------------------------
 // Debugging code
 void ObjectSynchronizer::sanity_checks(const bool verbose,
 const uint cache_line_size,

changeset 35934	76dbe86f3d82
parent 35492	c8c0273e6b91
child 37092	0e56e3c9d545