rename relaxed_store => store_relaxed

Author: kimbarrett

src/hotspot/share/gc/shared/freeListAllocator.cpp

@@ -53,9 +53,9 @@ size_t FreeListAllocator::PendingList::add(FreeNode* node) {
 
 typename FreeListAllocator::NodeList FreeListAllocator::PendingList::take_all() {
   NodeList result{_head.load_relaxed(), _tail, _count.load_relaxed()};
-  _head.relaxed_store(nullptr);
+  _head.store_relaxed(nullptr);
   _tail = nullptr;
-  _count.relaxed_store(0u);
+  _count.store_relaxed(0u);
   return result;
 }
 
@@ -96,7 +96,7 @@ void FreeListAllocator::reset() {
   uint index = _active_pending_list.load_relaxed();
   _pending_lists[index].take_all();
   _free_list.pop_all();
-  _free_count.relaxed_store(0u);
+  _free_count.store_relaxed(0u);
 }
 
 size_t FreeListAllocator::free_count() const {

src/hotspot/share/gc/shared/freeListAllocator.hpp

@@ -70,7 +70,7 @@ class FreeListAllocator {
 
     Atomic<FreeNode*>* next_addr() { return &_next; }
 
-    void set_next(FreeNode* next) { _next.relaxed_store(next); }
+    void set_next(FreeNode* next) { _next.store_relaxed(next); }
   };
 
   struct NodeList {

src/hotspot/share/gc/shared/stringdedup/stringDedupTable.cpp

@@ -245,13 +245,13 @@ void StringDedup::Table::num_dead_callback(size_t num_dead) {
 
   switch (_dead_state.load_relaxed()) {
   case DeadState::good:
-    _dead_count.relaxed_store(num_dead);
+    _dead_count.store_relaxed(num_dead);
     break;
 
   case DeadState::wait1:
     // Set count first, so dedup thread gets this or a later value if it
     // sees the good state.
-    _dead_count.relaxed_store(num_dead);
+    _dead_count.store_relaxed(num_dead);
     _dead_state.release_store(DeadState::good);
     break;
 
@@ -672,8 +672,8 @@ bool StringDedup::Table::cleanup_start_if_needed(bool grow_only, bool force) {
 
 void StringDedup::Table::set_dead_state_cleaning() {
   MutexLocker ml(StringDedup_lock, Mutex::_no_safepoint_check_flag);
-  _dead_count.relaxed_store(0);
-  _dead_state.relaxed_store(DeadState::cleaning);
+  _dead_count.store_relaxed(0);
+  _dead_state.store_relaxed(DeadState::cleaning);
 }
 
 bool StringDedup::Table::start_resizer(bool grow_only, size_t number_of_entries) {
@@ -707,7 +707,7 @@ void StringDedup::Table::cleanup_end() {
   delete _cleanup_state;
   _cleanup_state = nullptr;
   MutexLocker ml(StringDedup_lock, Mutex::_no_safepoint_check_flag);
-  _dead_state.relaxed_store(DeadState::wait2);
+  _dead_state.store_relaxed(DeadState::wait2);
 }
 
 void StringDedup::Table::verify() {

src/hotspot/share/runtime/atomic.hpp

@@ -72,7 +72,7 @@
 //   member functions:
 //     v.load_relaxed() -> T
 //     v.load_acquire() -> T
-//     v.relaxed_store(x) -> void
+//     v.store_relaxed(x) -> void
 //     v.release_store(x) -> void
 //     v.release_store_fence(x) -> void
 //     v.cmpxchg(x, y [, o]) -> T
@@ -156,9 +156,9 @@
 // for testing for that are not provided. (There might have been some types on
 // some platforms that used a lock long-ago, but that's no longer the case.)
 //
-// * Rather than load/store operations with a memory order parameter,
-// Atomic<T> provides load_{relaxed,acquire}() and {relaxed,release}_store()
-// operations, as well as release_store_fence().
+// * Rather than load and store operations with a memory order parameter,
+// Atomic<T> provides load_relaxed(), load_acquire(), release_store(),
+// store_relaxed(), and release_store_fence() operations.
 //
 // * Atomic<T> doesn't provide operator overloads that perform various
 // operations with sequentially consistent ordering semantics. The rationale
@@ -266,7 +266,7 @@ class AtomicImpl::CommonCore {
     return AtomicAccess::load_acquire(value_ptr());
   }
 
-  void relaxed_store(T value) {
+  void store_relaxed(T value) {
     AtomicAccess::store(value_ptr(), value);
   }
 
@@ -546,8 +546,8 @@ class AtomicImpl::Atomic<T, AtomicImpl::Category::Translated>
     return recover(_value.load_acquire());
   }
 
-  void relaxed_store(T value) {
-    _value.relaxed_store(decay(value));
+  void store_relaxed(T value) {
+    _value.store_relaxed(decay(value));
   }
 
   void release_store(T value) {

src/hotspot/share/utilities/atomicNextAccess.hpp

@@ -72,7 +72,7 @@ struct AtomicNextAccess<T, next_access> {
   }
 
   static void set_next(T& value, T* new_next) {
-    next_access(value)->relaxed_store(new_next);
+    next_access(value)->store_relaxed(new_next);
   }
 
   static T* cmpxchg(T& value, const T* compare, T* exchange) {

src/hotspot/share/utilities/nonblockingQueue.inline.hpp

@@ -137,7 +137,7 @@ void NonblockingQueue<T, next_access>::append(T& first, T& last) {
   }
   // The queue was empty, and first should become the new _head.  The queue
   // will appear to be empty to any further try_pops until done.
-  _head.relaxed_store(&first);
+  _head.store_relaxed(&first);
 }
 
 template<typename T, auto next_access>
@@ -243,8 +243,8 @@ Pair<T*, T*> NonblockingQueue<T, next_access>::take_all() {
   T* tail = _tail.load_relaxed();
   if (tail != nullptr) set_next(*tail, nullptr); // Clear end marker.
   Pair<T*, T*> result(_head.load_relaxed(), tail);
-  _head.relaxed_store(nullptr);
-  _tail.relaxed_store(nullptr);
+  _head.store_relaxed(nullptr);
+  _tail.store_relaxed(nullptr);
   return result;
 }
 

src/hotspot/share/utilities/singleWriterSynchronizer.cpp

@@ -62,7 +62,7 @@ void SingleWriterSynchronizer::synchronize() {
   uint old;
   do {
     old = value;
-    new_exit.relaxed_store(++value);
+    new_exit.store_relaxed(++value);
     value = _enter.cmpxchg(old, value);
   } while (old != value);
   // Critical sections entered before we changed the polarity will use
@@ -74,7 +74,7 @@ void SingleWriterSynchronizer::synchronize() {
   // a pending synchronize waiting.  The thread that completes the
   // request (_exit value == old) will signal the _wakeup semaphore to
   // allow us to proceed.
-  _waiting_for.relaxed_store(old);
+  _waiting_for.store_relaxed(old);
   // Write of _waiting_for must precede read of _exit and associated
   // conditional semaphore wait.  If they were re-ordered then a
   // critical section exit could miss the wakeup request, failing to