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

equal deleted inserted replaced

-:f3546d51ce9c
+:4cfe0e5a3b79
 /*
-* Copyright (c) 1998, 2018, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1998, 2019, 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.
 return;
 }
 }
 // We have to take the slow-path of possible inflation and then exit.
-ObjectSynchronizer::inflate(THREAD,
+inflate(THREAD, object, inflate_cause_vm_internal)->exit(true, 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,
+inflate(THREAD, obj(), inflate_cause_monitor_enter)->enter(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,
+ObjectMonitor* monitor = inflate(THREAD, obj(), inflate_cause_vm_internal);
-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,
+ObjectMonitor* monitor = inflate(THREAD, obj(), inflate_cause_vm_internal);
-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(), inflate_cause_jni_enter)->enter(THREAD);
+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,
+ObjectMonitor* monitor = inflate(THREAD, obj, inflate_cause_jni_exit);
-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);
 }
 assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
 }
 if (millis < 0) {
 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "timeout value is negative");
 }
-ObjectMonitor* monitor = ObjectSynchronizer::inflate(THREAD,
+ObjectMonitor* monitor = inflate(THREAD, obj(), inflate_cause_wait);
-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
 assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
 }
 if (millis < 0) {
 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "timeout value is negative");
 }
-ObjectSynchronizer::inflate(THREAD,
+inflate(THREAD, obj(), inflate_cause_wait)->wait(millis, false, 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,
+inflate(THREAD, obj(), inflate_cause_notify)->notify(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,
+inflate(THREAD, obj(), inflate_cause_notify)->notifyAll(THREAD);
-obj(),
-inflate_cause_notify)->notifyAll(THREAD);
 }
 // -----------------------------------------------------------------------------
 // Hash Code handling
 //
 // object should remain ineligible for biased locking
 assert(!mark->has_bias_pattern(), "invariant");
 if (mark->is_neutral()) {
 hash = mark->hash();              // this is a normal header
-if (hash) {                       // if it has hash, just return it
+if (hash != 0) {                  // if it has hash, just return it
 return hash;
 }
 hash = get_next_hash(Self, obj);  // allocate a new hash code
 temp = mark->copy_set_hash(hash); // merge the hash code into header
 // use (machine word version) atomic operation to install the hash
 // into heavy weight monitor. We could add more code here
 // for fast path, but it does not worth the complexity.
 } else if (mark->has_monitor()) {
 monitor = mark->monitor();
 temp = monitor->header();
-assert(temp->is_neutral(), "invariant");
+assert(temp->is_neutral(), "invariant: header=" INTPTR_FORMAT, p2i((address)temp));
 hash = temp->hash();
-if (hash) {
+if (hash != 0) {
 return hash;
 }
 // Skip to the following code to reduce code size
 } else if (Self->is_lock_owned((address)mark->locker())) {
 temp = mark->displaced_mark_helper(); // this is a lightweight monitor owned
-assert(temp->is_neutral(), "invariant");
+assert(temp->is_neutral(), "invariant: header=" INTPTR_FORMAT, p2i((address)temp));
 hash = temp->hash();              // by current thread, check if the displaced
-if (hash) {                       // header contains hash code
+if (hash != 0) {                  // header contains hash code
 return hash;
 }
 // WARNING:
 //   The displaced header is strictly immutable.
 // It can NOT be changed in ANY cases. So we have
 // Any change to stack may not propagate to other threads
 // correctly.
 }
 // Inflate the monitor to set hash code
-monitor = ObjectSynchronizer::inflate(Self, obj, inflate_cause_hash_code);
+monitor = inflate(Self, obj, inflate_cause_hash_code);
 // Load displaced header and check it has hash code
 mark = monitor->header();
-assert(mark->is_neutral(), "invariant");
+assert(mark->is_neutral(), "invariant: header=" INTPTR_FORMAT, p2i((address)mark));
 hash = mark->hash();
 if (hash == 0) {
 hash = get_next_hash(Self, obj);
 temp = mark->copy_set_hash(hash); // merge hash code into header
-assert(temp->is_neutral(), "invariant");
+assert(temp->is_neutral(), "invariant: header=" INTPTR_FORMAT, p2i((address)temp));
 test = Atomic::cmpxchg(temp, monitor->header_addr(), mark);
 if (test != mark) {
 // The only update to the header in the monitor (outside GC)
 // is install the hash code. If someone add new usage of
 // displaced header, please update this code
 hash = test->hash();
-assert(test->is_neutral(), "invariant");
+assert(test->is_neutral(), "invariant: header=" INTPTR_FORMAT, p2i((address)test));
 assert(hash != 0, "Trivial unexpected object/monitor header usage.");
 }
 }
 // We finally get the hash
 return hash;
 if (mark->has_locker()) {
 return self->is_lock_owned((address)mark->locker()) ?
 owner_self : owner_other;
 }
-// CASE: inflated. Mark (tagged pointer) points to an objectMonitor.
+// CASE: inflated. Mark (tagged pointer) points to an ObjectMonitor.
 // The Object:ObjectMonitor relationship is stable as long as we're
 // not at a safepoint.
 if (mark->has_monitor()) {
 void * owner = mark->monitor()->_owner;
 if (owner == NULL) return owner_none;
 if (mark->has_locker()) {
 owner = (address) mark->locker();
 }
 // Contended case, header points to ObjectMonitor (tagged pointer)
-if (mark->has_monitor()) {
+else if (mark->has_monitor()) {
 ObjectMonitor* monitor = mark->monitor();
 assert(monitor != NULL, "monitor should be non-null");
 owner = (address) monitor->owner();
 }
 // to reprovision the caller's free list.
 if (gFreeList != NULL) {
 // Reprovision the thread's omFreeList.
 // Use bulk transfers to reduce the allocation rate and heat
 // on various locks.
-Thread::muxAcquire(&gListLock, "omAlloc");
+Thread::muxAcquire(&gListLock, "omAlloc(1)");
 for (int i = Self->omFreeProvision; --i >= 0 && gFreeList != NULL;) {
 gMonitorFreeCount--;
 ObjectMonitor * take = gFreeList;
 gFreeList = take->FreeNext;
 guarantee(take->object() == NULL, "invariant");
 // block in hand.  This avoids some lock traffic and redundant
 // list activity.
 // Acquire the gListLock to manipulate gBlockList and gFreeList.
 // An Oyama-Taura-Yonezawa scheme might be more efficient.
-Thread::muxAcquire(&gListLock, "omAlloc [2]");
+Thread::muxAcquire(&gListLock, "omAlloc(2)");
 gMonitorPopulation += _BLOCKSIZE-1;
 gMonitorFreeCount += _BLOCKSIZE-1;
 // Add the new block to the list of extant blocks (gBlockList).
 // The very first objectMonitor in a block is reserved and dedicated.
 // attempt failed.  This doesn't allow unbounded #s of monitors to
 // accumulate on a thread's free list.
 //
 // Key constraint: all ObjectMonitors on a thread's free list and the global
 // free list must have their object field set to null. This prevents the
-// scavenger -- deflate_idle_monitors -- from reclaiming them.
+// scavenger -- deflate_monitor_list() -- from reclaiming them.
 void ObjectSynchronizer::omRelease(Thread * Self, ObjectMonitor * m,
 bool fromPerThreadAlloc) {
+guarantee(m->header() == NULL, "invariant");
 guarantee(m->object() == NULL, "invariant");
 guarantee(((m->is_busy()|m->_recursions) == 0), "freeing in-use monitor");
 // Remove from omInUseList
 if (fromPerThreadAlloc) {
 ObjectMonitor* cur_mid_in_use = NULL;
 // a global gOmInUseList under the global list lock so these
 // will continue to be scanned.
 //
 // We currently call omFlush() from Threads::remove() _before the thread
 // has been excised from the thread list and is no longer a mutator.
-// This means that omFlush() can not run concurrently with a safepoint and
+// This means that omFlush() cannot run concurrently with a safepoint and
-// interleave with the scavenge operator. In particular, this ensures that
+// interleave with the deflate_idle_monitors scavenge operator. In particular,
-// the thread's monitors are scanned by a GC safepoint, either via
+// this ensures that the thread's monitors are scanned by a GC safepoint,
-// Thread::oops_do() (if safepoint happens before omFlush()) or via
+// either via Thread::oops_do() (if safepoint happens before omFlush()) or via
 // ObjectSynchronizer::oops_do() (if it happens after omFlush() and the thread's
 // monitors have been transferred to the global in-use list).
 void ObjectSynchronizer::omFlush(Thread * Self) {
 ObjectMonitor * list = Self->omFreeList;  // Null-terminated SLL
-Self->omFreeList = NULL;
 ObjectMonitor * tail = NULL;
 int tally = 0;
 if (list != NULL) {
 ObjectMonitor * s;
 // The thread is going away, the per-thread free monitors
 tail = s;
 guarantee(s->object() == NULL, "invariant");
 guarantee(!s->is_busy(), "invariant");
 s->set_owner(NULL);   // redundant but good hygiene
 }
-guarantee(tail != NULL && list != NULL, "invariant");
+guarantee(tail != NULL, "invariant");
+assert(Self->omFreeCount == tally, "free-count off");
+Self->omFreeList = NULL;
+Self->omFreeCount = 0;
 }
 ObjectMonitor * inUseList = Self->omInUseList;
 ObjectMonitor * inUseTail = NULL;
 int inUseTally = 0;
 if (inUseList != NULL) {
-Self->omInUseList = NULL;
 ObjectMonitor *cur_om;
 // The thread is going away, however the omInUseList inflated
 // monitors may still be in-use by other threads.
 // Link them to inUseTail, which will be linked into the global in-use list
 // gOmInUseList below, under the gListLock
 for (cur_om = inUseList; cur_om != NULL; cur_om = cur_om->FreeNext) {
 inUseTail = cur_om;
 inUseTally++;
 }
+guarantee(inUseTail != NULL, "invariant");
 assert(Self->omInUseCount == inUseTally, "in-use count off");
+Self->omInUseList = NULL;
 Self->omInUseCount = 0;
-guarantee(inUseTail != NULL && inUseList != NULL, "invariant");
 }
 Thread::muxAcquire(&gListLock, "omFlush");
 if (tail != NULL) {
 tail->FreeNext = gFreeList;
 gFreeList = list;
 gMonitorFreeCount += tally;
-assert(Self->omFreeCount == tally, "free-count off");
-Self->omFreeCount = 0;
 }
 if (inUseTail != NULL) {
 inUseTail->FreeNext = gOmInUseList;
 gOmInUseList = inUseList;
 event->set_cause((u1)cause);
 event->commit();
 }
 // Fast path code shared by multiple functions
-ObjectMonitor* ObjectSynchronizer::inflate_helper(oop obj) {
+void ObjectSynchronizer::inflate_helper(oop obj) {
 markOop mark = obj->mark();
 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;
 }
-return ObjectSynchronizer::inflate(Thread::current(),
+inflate(Thread::current(), obj, inflate_cause_vm_internal);
-obj,
-inflate_cause_vm_internal);
 }
 ObjectMonitor* ObjectSynchronizer::inflate(Thread * Self,
 oop object,
 const InflateCause cause) {
 // Inflate mutates the heap ...
 // Relaxing assertion for bug 6320749.
 assert(Universe::verify_in_progress() ||
 !SafepointSynchronize::is_at_safepoint(), "invariant");
 // *  BIASED       - Illegal.  We should never see this
 // CASE: inflated
 if (mark->has_monitor()) {
 ObjectMonitor * inf = mark->monitor();
-assert(inf->header()->is_neutral(), "invariant");
+markOop dmw = inf->header();
+assert(dmw->is_neutral(), "invariant: header=" INTPTR_FORMAT, p2i((address)dmw));
 assert(oopDesc::equals((oop) inf->object(), object), "invariant");
 assert(ObjectSynchronizer::verify_objmon_isinpool(inf), "monitor is invalid");
 return inf;
 }
 // Hopefully the performance counters are allocated on distinct cache lines
 // to avoid false sharing on MP systems ...
 OM_PERFDATA_OP(Inflations, inc());
 if (log_is_enabled(Debug, monitorinflation)) {
 if (object->is_instance()) {
-ResourceMark rm;
+ResourceMark rm(Self);
-log_debug(monitorinflation)("Inflating object " INTPTR_FORMAT " , mark " INTPTR_FORMAT " , type %s",
+log_debug(monitorinflation)("inflate(has_locker): "
+"object=" INTPTR_FORMAT ", mark=" INTPTR_FORMAT ", type='%s'",
 p2i(object), p2i(object->mark()),
 object->klass()->external_name());
 }
 }
 if (event.should_commit()) {
 m->_recursions   = 0;
 m->_Responsible  = NULL;
 m->_SpinDuration = ObjectMonitor::Knob_SpinLimit;       // consider: keep metastats by type/class
 if (object->cas_set_mark(markOopDesc::encode(m), mark) != mark) {
+m->set_header(NULL);
 m->set_object(NULL);
-m->set_owner(NULL);
 m->Recycle();
 omRelease(Self, m, true);
 m = NULL;
 continue;
 // interference - the markword changed - just retry.
 // Hopefully the performance counters are allocated on distinct
 // cache lines to avoid false sharing on MP systems ...
 OM_PERFDATA_OP(Inflations, inc());
 if (log_is_enabled(Debug, monitorinflation)) {
 if (object->is_instance()) {
-ResourceMark rm;
+ResourceMark rm(Self);
-log_debug(monitorinflation)("Inflating object " INTPTR_FORMAT " , mark " INTPTR_FORMAT " , type %s",
+log_debug(monitorinflation)("inflate(neutral): "
+"object=" INTPTR_FORMAT ", mark=" INTPTR_FORMAT ", type='%s'",
 p2i(object), p2i(object->mark()),
 object->klass()->external_name());
 }
 }
 if (event.should_commit()) {
 // It's idle - scavenge and return to the global free list
 // plain old deflation ...
 if (log_is_enabled(Debug, monitorinflation)) {
 if (obj->is_instance()) {
 ResourceMark rm;
-log_debug(monitorinflation)("Deflating object " INTPTR_FORMAT " , "
+log_debug(monitorinflation)("deflate_monitor: "
-"mark " INTPTR_FORMAT " , type %s",
+"object=" INTPTR_FORMAT ", mark=" INTPTR_FORMAT ", type='%s'",
 p2i(obj), p2i(obj->mark()),
 obj->klass()->external_name());
 }
 }
 return deflated;
 }
 // Walk a given monitor list, and deflate idle monitors
 // The given list could be a per-thread list or a global list
-// Caller acquires gListLock.
+// Caller acquires gListLock as needed.
 //
 // In the case of parallel processing of thread local monitor lists,
 // work is done by Threads::parallel_threads_do() which ensures that
 // each Java thread is processed by exactly one worker thread, and
 // thus avoid conflicts that would arise when worker threads would
 }
 void ObjectSynchronizer::prepare_deflate_idle_monitors(DeflateMonitorCounters* counters) {
 counters->nInuse = 0;            // currently associated with objects
 counters->nInCirculation = 0;    // extant
-counters->nScavenged = 0;        // reclaimed
+counters->nScavenged = 0;        // reclaimed (global and per-thread)
 counters->perThreadTimes = 0.0;  // per-thread scavenge times
 }
 void ObjectSynchronizer::deflate_idle_monitors(DeflateMonitorCounters* counters) {
 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
 ObjectMonitor * freeTailp = NULL;
 // 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");
+Thread::muxAcquire(&gListLock, "deflate_idle_monitors");
 // Note: the thread-local monitors lists get deflated in
 // a separate pass. See deflate_thread_local_monitors().
 // For moribund threads, scan gOmInUseList
 int deflated_count = deflate_monitor_list(thread->omInUseList_addr(), &freeHeadp, &freeTailp);
 timer.stop();
-Thread::muxAcquire(&gListLock, "scavenge - return");
+Thread::muxAcquire(&gListLock, "deflate_thread_local_monitors");
 // Adjust counters
 counters->nInCirculation += thread->omInUseCount;
 thread->omInUseCount -= deflated_count;
 counters->nScavenged += deflated_count;

changeset 53557	4cfe0e5a3b79
parent 52703	e7fdc9d9c376
child 53588	a5f46c4690f8