src/share/vm/gc/shared/collectorPolicy.cpp

@@ -618,11 +618,11 @@
       if (result != NULL) {
         assert(gch->is_in_reserved(result), "result not in heap");
         return result;
       }
 
-      if (GC_locker::is_active_and_needs_gc()) {
+      if (GCLocker::is_active_and_needs_gc()) {
         if (is_tlab) {
           return NULL;  // Caller will retry allocating individual object.
         }
         if (!gch->is_maximal_no_gc()) {
           // Try and expand heap to satisfy request.

@@ -645,11 +645,11 @@
         // rather than causing more, now probably unnecessary, GC attempts.
         JavaThread* jthr = JavaThread::current();
         if (!jthr->in_critical()) {
           MutexUnlocker mul(Heap_lock);
           // Wait for JNI critical section to be exited
-          GC_locker::stall_until_clear();
+          GCLocker::stall_until_clear();
           gclocker_stalled_count += 1;
           continue;
         } else {
           if (CheckJNICalls) {
             fatal("Possible deadlock due to allocating while"

@@ -726,11 +726,11 @@
   GenCollectedHeap *gch = GenCollectedHeap::heap();
   GCCauseSetter x(gch, GCCause::_allocation_failure);
   HeapWord* result = NULL;
 
   assert(size != 0, "Precondition violated");
-  if (GC_locker::is_active_and_needs_gc()) {
+  if (GCLocker::is_active_and_needs_gc()) {
     // GC locker is active; instead of a collection we will attempt
     // to expand the heap, if there's room for expansion.
     if (!gch->is_maximal_no_gc()) {
       result = expand_heap_and_allocate(size, is_tlab);
     }

@@ -813,12 +813,12 @@
     MetaWord* result = loader_data->metaspace_non_null()->allocate(word_size, mdtype);
     if (result != NULL) {
       return result;
     }
 
-    if (GC_locker::is_active_and_needs_gc()) {
-      // If the GC_locker is active, just expand and allocate.
+    if (GCLocker::is_active_and_needs_gc()) {
+      // If the GCLocker is active, just expand and allocate.
       // If that does not succeed, wait if this thread is not
       // in a critical section itself.
       result =
         loader_data->metaspace_non_null()->expand_and_allocate(word_size,
                                                                mdtype);

@@ -826,11 +826,11 @@
         return result;
       }
       JavaThread* jthr = JavaThread::current();
       if (!jthr->in_critical()) {
         // Wait for JNI critical section to be exited
-        GC_locker::stall_until_clear();
+        GCLocker::stall_until_clear();
         // The GC invoked by the last thread leaving the critical
         // section will be a young collection and a full collection
         // is (currently) needed for unloading classes so continue
         // to the next iteration to get a full GC.
         continue;

@@ -885,11 +885,11 @@
 bool GenCollectorPolicy::should_try_older_generation_allocation(
         size_t word_size) const {
   GenCollectedHeap* gch = GenCollectedHeap::heap();
   size_t young_capacity = gch->young_gen()->capacity_before_gc();
   return    (word_size > heap_word_size(young_capacity))
-         || GC_locker::is_active_and_needs_gc()
+         || GCLocker::is_active_and_needs_gc()
          || gch->incremental_collection_failed();
 }
 
 
 //