Introduce SealingBlockLastRequest

It will limit the lifetime of lock guard.

Author: majecty

core/src/miner/miner.rs

@@ -115,7 +115,7 @@ pub struct Miner {
     mem_pool: Arc<RwLock<MemPool>>,
     next_allowed_reseal: NextAllowedReseal,
     next_mandatory_reseal: NextMandatoryReseal,
-    sealing_block_last_request: Mutex<u64>,
+    sealing_block_last_request: SealingBlockLastRequest,
     sealing_work: Mutex<SealingWork>,
     params: Params,
     engine: Arc<dyn CodeChainEngine>,
@@ -129,6 +129,30 @@ pub struct Miner {
     immune_users: RwLock<HashSet<Address>>,
 }
 
+struct SealingBlockLastRequest {
+    block_number: Mutex<u64>,
+}
+
+impl SealingBlockLastRequest {
+    pub fn new() -> Self {
+        Self {
+            block_number: Mutex::new(0),
+        }
+    }
+
+    pub fn get(&self) -> u64 {
+        *self.block_number.lock()
+    }
+
+    /// Returns previous value
+    pub fn set(&self, block_number: u64) -> u64 {
+        let mut guard = self.block_number.lock();
+        let prev = *guard;
+        *guard = block_number;
+        prev
+    }
+}
+
 struct NextAllowedReseal {
     instant: Mutex<Instant>,
 }
@@ -236,7 +260,7 @@ impl Miner {
             next_allowed_reseal: NextAllowedReseal::new(Instant::now()),
             next_mandatory_reseal: NextMandatoryReseal::new(Instant::now() + options.reseal_max_period),
             params: Params::new(AuthoringParams::default()),
-            sealing_block_last_request: Mutex::new(0),
+            sealing_block_last_request: SealingBlockLastRequest::new(),
             sealing_work: Mutex::new(SealingWork {
                 queue: SealingQueue::new(options.work_queue_size),
                 enabled: options.force_sealing || scheme.engine.seals_internally().is_some(),
@@ -280,7 +304,7 @@ impl Miner {
         let mut sealing_work = self.sealing_work.lock();
         if sealing_work.enabled {
             ctrace!(MINER, "requires_reseal: sealing enabled");
-            let last_request = *self.sealing_block_last_request.lock();
+            let last_request = self.sealing_block_last_request.get();
             let should_disable_sealing = !self.options.force_sealing
                 && !has_local_transactions
                 && self.engine.seals_internally().is_none()
@@ -908,16 +932,16 @@ impl MinerService for Miner {
                 }
             }
         }
-        let mut sealing_block_last_request = self.sealing_block_last_request.lock();
+
         let best_number = client.chain_info().best_block_number;
-        if *sealing_block_last_request != best_number {
+        let prev_request = self.sealing_block_last_request.set(best_number);
+        if prev_request != best_number {
             ctrace!(
                 MINER,
                 "prepare_work_sealing: Miner received request (was {}, now {}) - waking up.",
-                *sealing_block_last_request,
+                prev_request,
                 best_number
             );
-            *sealing_block_last_request = best_number;
         }
 
         // Return if we restarted