jdk8-mips64-public/hotspot: comparison src/share/vm/memory/gcLocker.hpp

-:072384a61312
+:1a2723f7ad8e
 /*
-* Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 2012, 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.
 // The direct lock/unlock calls do not force a collection if an unlock
 // decrements the count to zero. Avoid calling these if at all possible.
 class GC_locker: public AllStatic {
 private:
-static volatile jint _jni_lock_count;  // number of jni active instances
+// The _jni_lock_count keeps track of the number of threads that are
+// currently in a critical region.  It's only kept up to date when
+// _needs_gc is true.  The current value is computed during
+// safepointing and decremented during the slow path of GC_locker
+// unlocking.
+static volatile jint _jni_lock_count;  // number of jni active instances.
 static volatile jint _lock_count;      // number of other active instances
 static volatile bool _needs_gc;        // heap is filling, we need a GC
 // note: bool is typedef'd as jint
 static volatile bool _doing_gc;        // unlock_critical() is doing a GC
+static jlong         _wait_begin;      // Timestamp for the setting of _needs_gc.
+// Used only by printing code.
+#ifdef ASSERT
+// This lock count is updated for all operations and is used to
+// validate the jni_lock_count that is computed during safepoints.
+static volatile jint _debug_jni_lock_count;
+#endif
 // Accessors
 static bool is_jni_active() {
+assert(_needs_gc, "only valid when _needs_gc is set");
 return _jni_lock_count > 0;
 }
-static void set_needs_gc() {
+// At a safepoint, visit all threads and count the number of active
-assert(SafepointSynchronize::is_at_safepoint(),
+// critical sections.  This is used to ensure that all active
-"needs_gc is only set at a safepoint");
+// critical sections are exited before a new one is started.
-_needs_gc = true;
+static void verify_critical_count() NOT_DEBUG_RETURN;
-}
+static void jni_lock(JavaThread* thread);
-static void clear_needs_gc() {
+static void jni_unlock(JavaThread* thread);
-assert_lock_strong(JNICritical_lock);
-_needs_gc = false;
-}
-static void jni_lock() {
-Atomic::inc(&_jni_lock_count);
-CHECK_UNHANDLED_OOPS_ONLY(
-if (CheckUnhandledOops) { Thread::current()->_gc_locked_out_count++; })
-assert(Universe::heap() == NULL || !Universe::heap()->is_gc_active(),
-"locking failed");
-}
-static void jni_unlock() {
-Atomic::dec(&_jni_lock_count);
-CHECK_UNHANDLED_OOPS_ONLY(
-if (CheckUnhandledOops) { Thread::current()->_gc_locked_out_count--; })
-}
-static void jni_lock_slow();
-static void jni_unlock_slow();
 public:
 // Accessors
 static bool is_active();
 static bool needs_gc()       { return _needs_gc;                        }
 // Shorthand
-static bool is_active_and_needs_gc() { return is_active() && needs_gc();}
+static bool is_active_and_needs_gc() { return needs_gc() && is_active(); }
-// Calls set_needs_gc() if is_active() is true. Returns is_active().
+// In debug mode track the locking state at all times
+static void increment_debug_jni_lock_count() {
+#ifdef ASSERT
+assert(_debug_jni_lock_count >= 0, "bad value");
+Atomic::inc(&_debug_jni_lock_count);
+#endif
+}
+static void decrement_debug_jni_lock_count() {
+#ifdef ASSERT
+assert(_debug_jni_lock_count > 0, "bad value");
+Atomic::dec(&_debug_jni_lock_count);
+#endif
+}
+// Set the current lock count
+static void set_jni_lock_count(int count) {
+_jni_lock_count = count;
+verify_critical_count();
+}
+// Sets _needs_gc if is_active() is true. Returns is_active().
 static bool check_active_before_gc();
 // Stalls the caller (who should not be in a jni critical section)
 // until needs_gc() clears. Note however that needs_gc() may be
 // set at a subsequent safepoint and/or cleared under the
 // we must allow threads already in critical regions to continue.
 //
 // JNI critical regions are the only participants in this scheme
 // because they are, by spec, well bounded while in a critical region.
 //
-// Each of the following two method is split into a fast path and a slow
+// Each of the following two method is split into a fast path and a
-// path. JNICritical_lock is only grabbed in the slow path.
+// slow path. JNICritical_lock is only grabbed in the slow path.
 // _needs_gc is initially false and every java thread will go
-// through the fast path (which does the same thing as the slow path
+// through the fast path, which simply increments or decrements the
-// when _needs_gc is false). When GC happens at a safepoint,
+// current thread's critical count.  When GC happens at a safepoint,
-// GC_locker::is_active() is checked. Since there is no safepoint in the
+// GC_locker::is_active() is checked. Since there is no safepoint in
-// fast path of lock_critical() and unlock_critical(), there is no race
+// the fast path of lock_critical() and unlock_critical(), there is
-// condition between the fast path and GC. After _needs_gc is set at a
+// no race condition between the fast path and GC. After _needs_gc
-// safepoint, every thread will go through the slow path after the safepoint.
+// is set at a safepoint, every thread will go through the slow path
-// Since after a safepoint, each of the following two methods is either
+// after the safepoint.  Since after a safepoint, each of the
-// entered from the method entry and falls into the slow path, or is
+// following two methods is either entered from the method entry and
-// resumed from the safepoints in the method, which only exist in the slow
+// falls into the slow path, or is resumed from the safepoints in
-// path. So when _needs_gc is set, the slow path is always taken, till
+// the method, which only exist in the slow path. So when _needs_gc
-// _needs_gc is cleared.
+// is set, the slow path is always taken, till _needs_gc is cleared.
 static void lock_critical(JavaThread* thread);
 static void unlock_critical(JavaThread* thread);
 };

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/memory/gcLocker.hpp

src/share/vm/memory/gcLocker.hpp