diff -r a02753d5a0b2 -r d1221849ea3d hotspot/src/share/vm/runtime/synchronizer.cpp --- a/hotspot/src/share/vm/runtime/synchronizer.cpp Wed Sep 10 11:48:20 2014 -0600 +++ b/hotspot/src/share/vm/runtime/synchronizer.cpp Wed Sep 10 11:52:16 2014 -0600 @@ -57,7 +57,6 @@ // for instance. If you make changes here, make sure to modify the // interpreter, and both C1 and C2 fast-path inline locking code emission. // -// // ----------------------------------------------------------------------------- #ifdef DTRACE_ENABLED @@ -77,10 +76,10 @@ #define DTRACE_MONITOR_WAIT_PROBE(monitor, obj, thread, millis) \ { \ - if (DTraceMonitorProbes) { \ + if (DTraceMonitorProbes) { \ DTRACE_MONITOR_PROBE_COMMON(obj, thread); \ HOTSPOT_MONITOR_WAIT(jtid, \ - (uintptr_t)(monitor), bytes, len, (millis)); \ + (uintptr_t)(monitor), bytes, len, (millis)); \ } \ } @@ -88,10 +87,10 @@ #define DTRACE_MONITOR_PROBE(probe, monitor, obj, thread) \ { \ - if (DTraceMonitorProbes) { \ + if (DTraceMonitorProbes) { \ DTRACE_MONITOR_PROBE_COMMON(obj, thread); \ HOTSPOT_MONITOR_PROBE_##probe(jtid, /* probe = waited */ \ - (uintptr_t)(monitor), bytes, len); \ + (uintptr_t)(monitor), bytes, len); \ } \ } @@ -116,8 +115,8 @@ ObjectMonitor * volatile ObjectSynchronizer::gOmInUseList = NULL; int ObjectSynchronizer::gOmInUseCount = 0; static volatile intptr_t ListLock = 0; // protects global monitor free-list cache -static volatile int MonitorFreeCount = 0; // # on gFreeList -static volatile int MonitorPopulation = 0; // # Extant -- in circulation +static volatile int MonitorFreeCount = 0; // # on gFreeList +static volatile int MonitorPopulation = 0; // # Extant -- in circulation #define CHAINMARKER (cast_to_oop(-1)) // ----------------------------------------------------------------------------- @@ -127,7 +126,8 @@ // if the following function is changed. The implementation is // extremely sensitive to race condition. Be careful. -void ObjectSynchronizer::fast_enter(Handle obj, BasicLock* lock, bool attempt_rebias, TRAPS) { +void ObjectSynchronizer::fast_enter(Handle obj, BasicLock* lock, + bool attempt_rebias, TRAPS) { if (UseBiasedLocking) { if (!SafepointSynchronize::is_at_safepoint()) { BiasedLocking::Condition cond = BiasedLocking::revoke_and_rebias(obj, attempt_rebias, THREAD); @@ -198,8 +198,8 @@ return; } // Fall through to inflate() ... - } else - if (mark->has_locker() && THREAD->is_lock_owned((address)mark->locker())) { + } else if (mark->has_locker() && + THREAD->is_lock_owned((address)mark->locker())) { assert(lock != mark->locker(), "must not re-lock the same lock"); assert(lock != (BasicLock*)obj->mark(), "don't relock with same BasicLock"); lock->set_displaced_header(NULL); @@ -261,7 +261,7 @@ // ----------------------------------------------------------------------------- // JNI locks on java objects // NOTE: must use heavy weight monitor to handle jni monitor enter -void ObjectSynchronizer::jni_enter(Handle obj, TRAPS) { // possible entry from jni enter +void ObjectSynchronizer::jni_enter(Handle obj, TRAPS) { // the current locking is from JNI instead of Java code TEVENT(jni_enter); if (UseBiasedLocking) { @@ -349,7 +349,7 @@ return dtrace_waited_probe(monitor, obj, THREAD); } -void ObjectSynchronizer::waitUninterruptibly (Handle obj, jlong millis, TRAPS) { +void ObjectSynchronizer::waitUninterruptibly(Handle obj, jlong millis, TRAPS) { if (UseBiasedLocking) { BiasedLocking::revoke_and_rebias(obj, false, THREAD); assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now"); @@ -426,7 +426,7 @@ static int MonitorScavengeThreshold = 1000000; static volatile int ForceMonitorScavenge = 0; // Scavenge required and pending -static markOop ReadStableMark (oop obj) { +static markOop ReadStableMark(oop obj) { markOop mark = obj->mark(); if (!mark->is_being_inflated()) { return mark; // normal fast-path return @@ -510,7 +510,6 @@ // result in hashtable collisions and reduced hashtable efficiency. // There are simple ways to "diffuse" the middle address bits over the // generated hashCode values: -// static inline intptr_t get_next_hash(Thread * Self, oop obj) { intptr_t value = 0; @@ -520,21 +519,17 @@ // On MP system we'll have lots of RW access to a global, so the // mechanism induces lots of coherency traffic. value = os::random(); - } else - if (hashCode == 1) { + } else if (hashCode == 1) { // This variation has the property of being stable (idempotent) // between STW operations. This can be useful in some of the 1-0 // synchronization schemes. intptr_t addrBits = cast_from_oop(obj) >> 3; value = addrBits ^ (addrBits >> 5) ^ GVars.stwRandom; - } else - if (hashCode == 2) { + } else if (hashCode == 2) { value = 1; // for sensitivity testing - } else - if (hashCode == 3) { + } else if (hashCode == 3) { value = ++GVars.hcSequence; - } else - if (hashCode == 4) { + } else if (hashCode == 4) { value = cast_from_oop(obj); } else { // Marsaglia's xor-shift scheme with thread-specific state @@ -557,8 +552,8 @@ TEVENT(hashCode: GENERATE); return value; } -// -intptr_t ObjectSynchronizer::FastHashCode (Thread * Self, oop obj) { + +intptr_t ObjectSynchronizer::FastHashCode(Thread * Self, oop obj) { if (UseBiasedLocking) { // NOTE: many places throughout the JVM do not expect a safepoint // to be taken here, in particular most operations on perm gen @@ -592,7 +587,7 @@ ObjectMonitor* monitor = NULL; markOop temp, test; intptr_t hash; - markOop mark = ReadStableMark (obj); + markOop mark = ReadStableMark(obj); // object should remain ineligible for biased locking assert(!mark->has_bias_pattern(), "invariant"); @@ -706,7 +701,7 @@ // The caller must beware this method can revoke bias, and // revocation can result in a safepoint. assert(!SafepointSynchronize::is_at_safepoint(), "invariant"); - assert(self->thread_state() != _thread_blocked , "invariant"); + assert(self->thread_state() != _thread_blocked, "invariant"); // Possible mark states: neutral, biased, stack-locked, inflated @@ -841,7 +836,6 @@ // -- unassigned and on a thread's private omFreeList // -- assigned to an object. The object is inflated and the mark refers // to the objectmonitor. -// // Constraining monitor pool growth via MonitorBound ... @@ -859,9 +853,8 @@ // See also: GuaranteedSafepointInterval // // The current implementation uses asynchronous VM operations. -// -static void InduceScavenge (Thread * Self, const char * Whence) { +static void InduceScavenge(Thread * Self, const char * Whence) { // Induce STW safepoint to trim monitors // Ultimately, this results in a call to deflate_idle_monitors() in the near future. // More precisely, trigger an asynchronous STW safepoint as the number @@ -886,7 +879,7 @@ } } -void ObjectSynchronizer::verifyInUse (Thread *Self) { +void ObjectSynchronizer::verifyInUse(Thread *Self) { ObjectMonitor* mid; int inusetally = 0; for (mid = Self->omInUseList; mid != NULL; mid = mid->FreeNext) { @@ -901,7 +894,7 @@ assert(freetally == Self->omFreeCount, "free count off"); } -ObjectMonitor * NOINLINE ObjectSynchronizer::omAlloc (Thread * Self) { +ObjectMonitor * NOINLINE ObjectSynchronizer::omAlloc(Thread * Self) { // A large MAXPRIVATE value reduces both list lock contention // and list coherency traffic, but also tends to increase the // number of objectMonitors in circulation as well as the STW @@ -1032,9 +1025,9 @@ // omRelease is to return a monitor to the free list after a CAS // attempt failed. This doesn't allow unbounded #s of monitors to // accumulate on a thread's free list. -// -void ObjectSynchronizer::omRelease (Thread * Self, ObjectMonitor * m, bool fromPerThreadAlloc) { +void ObjectSynchronizer::omRelease(Thread * Self, ObjectMonitor * m, + bool fromPerThreadAlloc) { guarantee(m->object() == NULL, "invariant"); // Remove from omInUseList @@ -1086,7 +1079,7 @@ // be not inopportune interleavings between omFlush() and the scavenge // operator. -void ObjectSynchronizer::omFlush (Thread * Self) { +void ObjectSynchronizer::omFlush(Thread * Self) { ObjectMonitor * List = Self->omFreeList; // Null-terminated SLL Self->omFreeList = NULL; ObjectMonitor * Tail = NULL; @@ -1152,7 +1145,8 @@ // multiple locks occupy the same $ line. Padding might be appropriate. -ObjectMonitor * NOINLINE ObjectSynchronizer::inflate (Thread * Self, oop object) { +ObjectMonitor * NOINLINE ObjectSynchronizer::inflate(Thread * Self, + oop object) { // Inflate mutates the heap ... // Relaxing assertion for bug 6320749. assert(Universe::verify_in_progress() || @@ -1373,7 +1367,6 @@ // typically drives the scavenge rate. Large heaps can mean infrequent GC, // which in turn can mean large(r) numbers of objectmonitors in circulation. // This is an unfortunate aspect of this design. -// enum ManifestConstants { ClearResponsibleAtSTW = 0, @@ -1383,7 +1376,8 @@ // Deflate a single monitor if not in use // Return true if deflated, false if in use bool ObjectSynchronizer::deflate_monitor(ObjectMonitor* mid, oop obj, - ObjectMonitor** freeHeadp, ObjectMonitor** freeTailp) { + ObjectMonitor** freeHeadp, + ObjectMonitor** freeTailp) { bool deflated; // Normal case ... The monitor is associated with obj. guarantee(obj->mark() == markOopDesc::encode(mid), "invariant"); @@ -1427,7 +1421,8 @@ // Caller acquires ListLock int ObjectSynchronizer::walk_monitor_list(ObjectMonitor** listheadp, - ObjectMonitor** freeHeadp, ObjectMonitor** freeTailp) { + ObjectMonitor** freeHeadp, + ObjectMonitor** freeTailp) { ObjectMonitor* mid; ObjectMonitor* next; ObjectMonitor* curmidinuse = NULL;