test/hotspot/gtest/gc/shared/test_ptrQueueBufferAllocator.cpp

@@ -24,11 +24,11 @@
 
 #include "precompiled.hpp"
 #include "gc/shared/ptrQueue.hpp"
 #include "memory/allocation.hpp"
 #include "runtime/interfaceSupport.inline.hpp"
-#include "runtime/orderAccess.hpp"
+#include "runtime/atomic.hpp"
 #include "runtime/semaphore.inline.hpp"
 #include "runtime/thread.hpp"
 #include "utilities/globalCounter.inline.hpp"
 #include "utilities/globalDefinitions.hpp"
 #include "utilities/ostream.hpp"

@@ -148,11 +148,11 @@
     _continue_running(continue_running),
     _allocations(0)
   {}
 
   virtual void main_run() {
-    while (OrderAccess::load_acquire(_continue_running)) {
+    while (Atomic::load_acquire(_continue_running)) {
       BufferNode* node = _allocator->allocate();
       _cbl->push(node);
       ++_allocations;
       ThreadBlockInVM tbiv(this); // Safepoint check.
     }

@@ -182,11 +182,11 @@
   virtual void main_run() {
     while (true) {
       BufferNode* node = _cbl->pop();
       if (node != NULL) {
         _allocator->release(node);
-      } else if (!OrderAccess::load_acquire(_continue_running)) {
+      } else if (!Atomic::load_acquire(_continue_running)) {
         return;
       }
       ThreadBlockInVM tbiv(this); // Safepoint check.
     }
   }

@@ -224,16 +224,16 @@
   tty->print_cr("Stressing allocator for %u ms", milliseconds_to_run);
   {
     ThreadInVMfromNative invm(this_thread);
     this_thread->sleep(milliseconds_to_run);
   }
-  OrderAccess::release_store(&allocator_running, false);
+  Atomic::release_store(&allocator_running, false);
   for (uint i = 0; i < nthreads; ++i) {
     ThreadInVMfromNative invm(this_thread);
     post.wait_with_safepoint_check(this_thread);
   }
-  OrderAccess::release_store(&processor_running, false);
+  Atomic::release_store(&processor_running, false);
   for (uint i = 0; i < nthreads; ++i) {
     ThreadInVMfromNative invm(this_thread);
     post.wait_with_safepoint_check(this_thread);
   }
   ASSERT_TRUE(BufferNode::TestSupport::try_transfer_pending(allocator));