hotspot/src/share/vm/gc/shared/gcLocker.cpp
changeset 35492 c8c0273e6b91
parent 35061 be6025ebffea
child 37226 9b0d4b523ce4
--- a/hotspot/src/share/vm/gc/shared/gcLocker.cpp	Thu Jan 14 09:18:11 2016 +0100
+++ b/hotspot/src/share/vm/gc/shared/gcLocker.cpp	Thu Jan 14 13:26:19 2016 +0100
@@ -30,17 +30,17 @@
 #include "runtime/atomic.inline.hpp"
 #include "runtime/thread.inline.hpp"
 
-volatile jint GC_locker::_jni_lock_count = 0;
-volatile bool GC_locker::_needs_gc       = false;
-volatile bool GC_locker::_doing_gc       = false;
+volatile jint GCLocker::_jni_lock_count = 0;
+volatile bool GCLocker::_needs_gc       = false;
+volatile bool GCLocker::_doing_gc       = false;
 
 #ifdef ASSERT
-volatile jint GC_locker::_debug_jni_lock_count = 0;
+volatile jint GCLocker::_debug_jni_lock_count = 0;
 #endif
 
 
 #ifdef ASSERT
-void GC_locker::verify_critical_count() {
+void GCLocker::verify_critical_count() {
   if (SafepointSynchronize::is_at_safepoint()) {
     assert(!needs_gc() || _debug_jni_lock_count == _jni_lock_count, "must agree");
     int count = 0;
@@ -63,18 +63,18 @@
 }
 
 // In debug mode track the locking state at all times
-void GC_locker::increment_debug_jni_lock_count() {
+void GCLocker::increment_debug_jni_lock_count() {
   assert(_debug_jni_lock_count >= 0, "bad value");
   Atomic::inc(&_debug_jni_lock_count);
 }
 
-void GC_locker::decrement_debug_jni_lock_count() {
+void GCLocker::decrement_debug_jni_lock_count() {
   assert(_debug_jni_lock_count > 0, "bad value");
   Atomic::dec(&_debug_jni_lock_count);
 }
 #endif
 
-void GC_locker::log_debug_jni(const char* msg) {
+void GCLocker::log_debug_jni(const char* msg) {
   LogHandle(gc, jni) log;
   if (log.is_debug()) {
     ResourceMark rm; // JavaThread::name() allocates to convert to UTF8
@@ -82,7 +82,7 @@
   }
 }
 
-bool GC_locker::check_active_before_gc() {
+bool GCLocker::check_active_before_gc() {
   assert(SafepointSynchronize::is_at_safepoint(), "only read at safepoint");
   if (is_active() && !_needs_gc) {
     verify_critical_count();
@@ -92,7 +92,7 @@
   return is_active();
 }
 
-void GC_locker::stall_until_clear() {
+void GCLocker::stall_until_clear() {
   assert(!JavaThread::current()->in_critical(), "Would deadlock");
   MutexLocker   ml(JNICritical_lock);
 
@@ -106,7 +106,7 @@
   }
 }
 
-void GC_locker::jni_lock(JavaThread* thread) {
+void GCLocker::jni_lock(JavaThread* thread) {
   assert(!thread->in_critical(), "shouldn't currently be in a critical region");
   MutexLocker mu(JNICritical_lock);
   // Block entering threads if we know at least one thread is in a
@@ -122,7 +122,7 @@
   increment_debug_jni_lock_count();
 }
 
-void GC_locker::jni_unlock(JavaThread* thread) {
+void GCLocker::jni_unlock(JavaThread* thread) {
   assert(thread->in_last_critical(), "should be exiting critical region");
   MutexLocker mu(JNICritical_lock);
   _jni_lock_count--;
@@ -143,49 +143,49 @@
   }
 }
 
-// Implementation of No_GC_Verifier
+// Implementation of NoGCVerifier
 
 #ifdef ASSERT
 
-No_GC_Verifier::No_GC_Verifier(bool verifygc) {
+NoGCVerifier::NoGCVerifier(bool verifygc) {
   _verifygc = verifygc;
   if (_verifygc) {
     CollectedHeap* h = Universe::heap();
-    assert(!h->is_gc_active(), "GC active during No_GC_Verifier");
+    assert(!h->is_gc_active(), "GC active during NoGCVerifier");
     _old_invocations = h->total_collections();
   }
 }
 
 
-No_GC_Verifier::~No_GC_Verifier() {
+NoGCVerifier::~NoGCVerifier() {
   if (_verifygc) {
     CollectedHeap* h = Universe::heap();
-    assert(!h->is_gc_active(), "GC active during No_GC_Verifier");
+    assert(!h->is_gc_active(), "GC active during NoGCVerifier");
     if (_old_invocations != h->total_collections()) {
-      fatal("collection in a No_GC_Verifier secured function");
+      fatal("collection in a NoGCVerifier secured function");
     }
   }
 }
 
-Pause_No_GC_Verifier::Pause_No_GC_Verifier(No_GC_Verifier * ngcv) {
+PauseNoGCVerifier::PauseNoGCVerifier(NoGCVerifier * ngcv) {
   _ngcv = ngcv;
   if (_ngcv->_verifygc) {
     // if we were verifying, then make sure that nothing is
     // wrong before we "pause" verification
     CollectedHeap* h = Universe::heap();
-    assert(!h->is_gc_active(), "GC active during No_GC_Verifier");
+    assert(!h->is_gc_active(), "GC active during NoGCVerifier");
     if (_ngcv->_old_invocations != h->total_collections()) {
-      fatal("collection in a No_GC_Verifier secured function");
+      fatal("collection in a NoGCVerifier secured function");
     }
   }
 }
 
 
-Pause_No_GC_Verifier::~Pause_No_GC_Verifier() {
+PauseNoGCVerifier::~PauseNoGCVerifier() {
   if (_ngcv->_verifygc) {
     // if we were verifying before, then reenable verification
     CollectedHeap* h = Universe::heap();
-    assert(!h->is_gc_active(), "GC active during No_GC_Verifier");
+    assert(!h->is_gc_active(), "GC active during NoGCVerifier");
     _ngcv->_old_invocations = h->total_collections();
   }
 }
@@ -201,16 +201,16 @@
 //   6) reaching a safepoint
 //   7) running too long
 // Nor may any method it calls.
-JRT_Leaf_Verifier::JRT_Leaf_Verifier()
-  : No_Safepoint_Verifier(true, JRT_Leaf_Verifier::should_verify_GC())
+JRTLeafVerifier::JRTLeafVerifier()
+  : NoSafepointVerifier(true, JRTLeafVerifier::should_verify_GC())
 {
 }
 
-JRT_Leaf_Verifier::~JRT_Leaf_Verifier()
+JRTLeafVerifier::~JRTLeafVerifier()
 {
 }
 
-bool JRT_Leaf_Verifier::should_verify_GC() {
+bool JRTLeafVerifier::should_verify_GC() {
   switch (JavaThread::current()->thread_state()) {
   case _thread_in_Java:
     // is in a leaf routine, there must be no safepoint.