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

equal deleted inserted replaced

-:9012aeaf993b
+:ebd5b1ad971a
 if (mark == (markOop) lock) {
 // If the object is stack-locked by the current thread, try to
 // swing the displaced header from the BasicLock back to the mark.
 assert(dhw->is_neutral(), "invariant");
 if (object->cas_set_mark(dhw, mark) == mark) {
-TEVENT(fast_exit: release stack-lock);
 return;
 }
 }
 // We have to take the slow-path of possible inflation and then exit.
 if (mark->is_neutral()) {
 // Anticipate successful CAS -- the ST of the displaced mark must
 // be visible <= the ST performed by the CAS.
 lock->set_displaced_header(mark);
 if (mark == obj()->cas_set_mark((markOop) lock, mark)) {
-TEVENT(slow_enter: release stacklock);
 return;
 }
 // Fall through to inflate() ...
 } else if (mark->has_locker() &&
 THREAD->is_lock_owned((address)mark->locker())) {
 //  3) when notified on lock2, unlock lock2
 //  4) reenter lock1 with original recursion count
 //  5) lock lock2
 // NOTE: must use heavy weight monitor to handle complete_exit/reenter()
 intptr_t ObjectSynchronizer::complete_exit(Handle obj, TRAPS) {
-TEVENT(complete_exit);
 if (UseBiasedLocking) {
 BiasedLocking::revoke_and_rebias(obj, false, THREAD);
 assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
 }
 return monitor->complete_exit(THREAD);
 }
 // NOTE: must use heavy weight monitor to handle complete_exit/reenter()
 void ObjectSynchronizer::reenter(Handle obj, intptr_t recursion, TRAPS) {
-TEVENT(reenter);
 if (UseBiasedLocking) {
 BiasedLocking::revoke_and_rebias(obj, false, THREAD);
 assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
 }
 // -----------------------------------------------------------------------------
 // JNI locks on java objects
 // NOTE: must use heavy weight monitor to handle jni monitor enter
 void ObjectSynchronizer::jni_enter(Handle obj, TRAPS) {
 // the current locking is from JNI instead of Java code
-TEVENT(jni_enter);
 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);
 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) {
-TEVENT(jni_exit);
 if (UseBiasedLocking) {
 Handle h_obj(THREAD, obj);
 BiasedLocking::revoke_and_rebias(h_obj, false, THREAD);
 obj = h_obj();
 }
 _thread = thread;
 debug_only(if (StrictSafepointChecks) _thread->check_for_valid_safepoint_state(false);)
 _obj = obj;
 if (_dolock) {
-TEVENT(ObjectLocker);
 ObjectSynchronizer::fast_enter(_obj, &_lock, false, _thread);
 }
 }
 ObjectLocker::~ObjectLocker() {
 if (UseBiasedLocking) {
 BiasedLocking::revoke_and_rebias(obj, false, THREAD);
 assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
 }
 if (millis < 0) {
-TEVENT(wait - throw IAX);
 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "timeout value is negative");
 }
 ObjectMonitor* monitor = ObjectSynchronizer::inflate(THREAD,
 obj(),
 inflate_cause_wait);
 if (UseBiasedLocking) {
 BiasedLocking::revoke_and_rebias(obj, false, THREAD);
 assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
 }
 if (millis < 0) {
-TEVENT(wait - throw IAX);
 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "timeout value is negative");
 }
 ObjectSynchronizer::inflate(THREAD,
 obj(),
 inflate_cause_wait)->wait(millis, false, THREAD);
 ++its;
 if (its > 10000 || !os::is_MP()) {
 if (its & 1) {
 os::naked_yield();
-TEVENT(Inflate: INFLATING - yield);
 } else {
 // Note that the following code attenuates the livelock problem but is not
 // a complete remedy.  A more complete solution would require that the inflating
 // thread hold the associated inflation lock.  The following code simply restricts
 // the number of spinners to at most one.  We'll have N-2 threads blocked
 } else {
 os::naked_yield();
 }
 }
 Thread::muxRelease(gInflationLocks + ix);
-TEVENT(Inflate: INFLATING - yield/park);
 }
 } else {
 SpinPause();       // SMP-polite spinning
 }
 }
 }
 value &= markOopDesc::hash_mask;
 if (value == 0) value = 0xBAD;
 assert(value != markOopDesc::no_hash, "invariant");
-TEVENT(hashCode: GENERATE);
 return value;
 }
 intptr_t ObjectSynchronizer::FastHashCode(Thread * Self, oop obj) {
 if (UseBiasedLocking) {
 omRelease(Self, take, false);
 }
 Thread::muxRelease(&gListLock);
 Self->omFreeProvision += 1 + (Self->omFreeProvision/2);
 if (Self->omFreeProvision > MAXPRIVATE) Self->omFreeProvision = MAXPRIVATE;
-TEVENT(omFirst - reprovision);
 const int mx = MonitorBound;
 if (mx > 0 && (gMonitorPopulation-gMonitorFreeCount) > mx) {
 // We can't safely induce a STW safepoint from omAlloc() as our thread
 // state may not be appropriate for such activities and callers may hold
 // Add the new string of objectMonitors to the global free list
 temp[_BLOCKSIZE - 1].FreeNext = gFreeList;
 gFreeList = temp + 1;
 Thread::muxRelease(&gListLock);
-TEVENT(Allocate block of monitors);
 }
 }
 // Place "m" on the caller's private per-thread omFreeList.
 // In practice there's no need to clamp or limit the number of
 tally++;
 tail = s;
 guarantee(s->object() == NULL, "invariant");
 guarantee(!s->is_busy(), "invariant");
 s->set_owner(NULL);   // redundant but good hygiene
-TEVENT(omFlush - Move one);
 }
 guarantee(tail != NULL && list != NULL, "invariant");
 }
 ObjectMonitor * inUseList = Self->omInUseList;
 gOmInUseList = inUseList;
 gOmInUseCount += inUseTally;
 }
 Thread::muxRelease(&gListLock);
-TEVENT(omFlush);
 }
 static void post_monitor_inflate_event(EventJavaMonitorInflate* event,
 const oop obj,
 ObjectSynchronizer::InflateCause cause) {
 // Only that thread can complete inflation -- other threads must wait.
 // The INFLATING value is transient.
 // Currently, we spin/yield/park and poll the markword, waiting for inflation to finish.
 // We could always eliminate polling by parking the thread on some auxiliary list.
 if (mark == markOopDesc::INFLATING()) {
-TEVENT(Inflate: spin while INFLATING);
 ReadStableMark(object);
 continue;
 }
 // CASE: stack-locked
 object->release_set_mark(markOopDesc::encode(m));
 // Hopefully the performance counters are allocated on distinct cache lines
 // to avoid false sharing on MP systems ...
 OM_PERFDATA_OP(Inflations, inc());
-TEVENT(Inflate: overwrite stacklock);
 if (log_is_enabled(Debug, monitorinflation)) {
 if (object->is_instance()) {
 ResourceMark rm;
 log_debug(monitorinflation)("Inflating object " INTPTR_FORMAT " , mark " INTPTR_FORMAT " , type %s",
 p2i(object), p2i(object->mark()),
 }
 // Hopefully the performance counters are allocated on distinct
 // cache lines to avoid false sharing on MP systems ...
 OM_PERFDATA_OP(Inflations, inc());
-TEVENT(Inflate: overwrite neutral);
 if (log_is_enabled(Debug, monitorinflation)) {
 if (object->is_instance()) {
 ResourceMark rm;
 log_debug(monitorinflation)("Inflating object " INTPTR_FORMAT " , mark " INTPTR_FORMAT " , type %s",
 p2i(object), p2i(object->mark()),
 deflated = false;
 } else {
 // Deflate the monitor if it is no longer being used
 // It's idle - scavenge and return to the global free list
 // plain old deflation ...
-TEVENT(deflate_idle_monitors - scavenge1);
 if (log_is_enabled(Debug, monitorinflation)) {
 if (obj->is_instance()) {
 ResourceMark rm;
 log_debug(monitorinflation)("Deflating object " INTPTR_FORMAT " , "
 "mark " INTPTR_FORMAT " , type %s",
 bool deflated = false;
 ObjectMonitor * freeHeadp = NULL;  // Local SLL of scavenged monitors
 ObjectMonitor * freeTailp = NULL;
-TEVENT(deflate_idle_monitors);
 // Prevent omFlush from changing mids in Thread dtor's during deflation
 // And in case the vm thread is acquiring a lock during a safepoint
 // See e.g. 6320749
 Thread::muxAcquire(&gListLock, "scavenge - return");

changeset 51702	ebd5b1ad971a
parent 51258	2ce72467c4e8
child 51860	54aafb3ba9ab