Replace unneeded seqcst with relaxed on atomic operations

core/src/rpc_pubsub.rs

@@ -120,7 +120,7 @@ impl RpcSolPubSub for RpcSolPubSubImpl {
     ) {
         match param::<Pubkey>(&pubkey_str, "pubkey") {
             Ok(pubkey) => {
-                let id = self.uid.fetch_add(1, atomic::Ordering::SeqCst);
+                let id = self.uid.fetch_add(1, atomic::Ordering::Relaxed);
                 let sub_id = SubscriptionId::Number(id as u64);
                 info!("account_subscribe: account={:?} id={:?}", pubkey, sub_id);
                 let sink = subscriber.assign_id(sub_id.clone()).unwrap();
@@ -158,7 +158,7 @@ impl RpcSolPubSub for RpcSolPubSubImpl {
     ) {
         match param::<Pubkey>(&pubkey_str, "pubkey") {
             Ok(pubkey) => {
-                let id = self.uid.fetch_add(1, atomic::Ordering::SeqCst);
+                let id = self.uid.fetch_add(1, atomic::Ordering::Relaxed);
                 let sub_id = SubscriptionId::Number(id as u64);
                 info!("program_subscribe: account={:?} id={:?}", pubkey, sub_id);
                 let sink = subscriber.assign_id(sub_id.clone()).unwrap();
@@ -197,7 +197,7 @@ impl RpcSolPubSub for RpcSolPubSubImpl {
         info!("signature_subscribe");
         match param::<Signature>(&signature_str, "signature") {
             Ok(signature) => {
-                let id = self.uid.fetch_add(1, atomic::Ordering::SeqCst);
+                let id = self.uid.fetch_add(1, atomic::Ordering::Relaxed);
                 let sub_id = SubscriptionId::Number(id as u64);
                 info!(
                     "signature_subscribe: signature={:?} id={:?}",

metrics/src/metrics.rs

@@ -460,7 +460,7 @@ mod test {
         }
 
         fn points_written(&self) -> usize {
-            return self.points_written.load(Ordering::SeqCst);
+            return self.points_written.load(Ordering::Relaxed);
         }
     }
 
@@ -469,12 +469,12 @@ mod test {
             assert!(!points.is_empty());
 
             self.points_written
-                .fetch_add(points.len(), Ordering::SeqCst);
+                .fetch_add(points.len(), Ordering::Relaxed);
 
             info!(
                 "Writing {} points ({} total)",
                 points.len(),
-                self.points_written.load(Ordering::SeqCst)
+                self.points_written.load(Ordering::Relaxed)
             );
         }
     }

runtime/src/bank.rs

@@ -288,8 +288,10 @@ impl Bank {
             .store(parent.transaction_count() as usize, Ordering::Relaxed);
         bank.stakes = RwLock::new(parent.stakes.read().unwrap().clone());
 
-        bank.tick_height
-            .store(parent.tick_height.load(Ordering::SeqCst), Ordering::SeqCst);
+        bank.tick_height.store(
+            parent.tick_height.load(Ordering::Relaxed),
+            Ordering::Relaxed,
+        );
         bank.ticks_per_slot = parent.ticks_per_slot;
         bank.epoch_schedule = parent.epoch_schedule;
 
@@ -385,7 +387,7 @@ impl Bank {
         let mut hash = self.hash.write().unwrap();
 
         if *hash == Hash::default() {
-            let collector_fees = self.collector_fees.load(Ordering::SeqCst) as u64;
+            let collector_fees = self.collector_fees.load(Ordering::Relaxed) as u64;
             if collector_fees != 0 {
                 self.deposit(&self.collector_id, collector_fees);
             }
@@ -582,8 +584,8 @@ impl Bank {
         // assert!(!self.is_frozen());
 
         let current_tick_height = {
-            self.tick_height.fetch_add(1, Ordering::SeqCst);
-            self.tick_height.load(Ordering::SeqCst) as u64
+            self.tick_height.fetch_add(1, Ordering::Relaxed);
+            self.tick_height.load(Ordering::Relaxed) as u64
         };
         inc_new_counter_debug!("bank-register_tick-registered", 1);
 
@@ -1109,7 +1111,7 @@ impl Bank {
         // tick_height is using an AtomicUSize because AtomicU64 is not yet a stable API.
         // Until we can switch to AtomicU64, fail if usize is not the same as u64
         assert_eq!(std::usize::MAX, 0xFFFF_FFFF_FFFF_FFFF);
-        self.tick_height.load(Ordering::SeqCst) as u64
+        self.tick_height.load(Ordering::Relaxed) as u64
     }
 
     /// Return this bank's max_tick_height
@@ -1200,12 +1202,12 @@ impl Bank {
         assert_eq!(self.ticks_per_slot, dbank.ticks_per_slot);
         assert_eq!(self.parent_hash, dbank.parent_hash);
         assert_eq!(
-            self.tick_height.load(Ordering::SeqCst),
-            dbank.tick_height.load(Ordering::SeqCst)
+            self.tick_height.load(Ordering::Relaxed),
+            dbank.tick_height.load(Ordering::Relaxed)
         );
         assert_eq!(
-            self.is_delta.load(Ordering::SeqCst),
-            dbank.is_delta.load(Ordering::SeqCst)
+            self.is_delta.load(Ordering::Relaxed),
+            dbank.is_delta.load(Ordering::Relaxed)
         );
 
         let st = self.stakes.read().unwrap();

runtime/src/serde_utils.rs

@@ -28,7 +28,7 @@ pub fn serialize_atomicusize<S>(x: &AtomicUsize, s: S) -> Result<S::Ok, S::Error
 where
     S: serde::Serializer,
 {
-    s.serialize_u64(x.load(Ordering::SeqCst) as u64)
+    s.serialize_u64(x.load(Ordering::Relaxed) as u64)
 }
 
 struct BoolVisitor;
@@ -58,5 +58,5 @@ pub fn serialize_atomicbool<S>(x: &AtomicBool, s: S) -> Result<S::Ok, S::Error>
 where
     S: serde::Serializer,
 {
-    s.serialize_bool(x.load(Ordering::SeqCst))
+    s.serialize_bool(x.load(Ordering::Relaxed))
 }