Remove map_sealing_work

Author: Seulgi Kim

core/src/miner/miner.rs

@@ -78,8 +78,6 @@ pub struct MinerOptions {
     /// Local transactions ignore this option.
     pub mem_pool_fee_bump_shift: usize,
     pub allow_create_shard: bool,
-    /// How many historical work packages can we store before running out?
-    pub work_queue_size: usize,
     /// Minimum fees configured by the machine.
     pub mem_pool_fees: MemPoolFees,
 }
@@ -98,7 +96,6 @@ impl Default for MinerOptions {
             mem_pool_memory_limit: Some(2 * 1024 * 1024),
             mem_pool_fee_bump_shift: 3,
             allow_create_shard: false,
-            work_queue_size: 20,
             mem_pool_fees: Default::default(),
         }
     }
@@ -184,7 +181,7 @@ impl Miner {
             params: RwLock::new(AuthoringParams::default()),
             sealing_block_last_request: Mutex::new(0),
             sealing_work: Mutex::new(SealingWork {
-                queue: SealingQueue::new(options.work_queue_size),
+                queue: SealingQueue::new(),
                 enabled: options.force_sealing,
             }),
             engine: scheme.engine.clone(),
@@ -881,19 +878,6 @@ impl MinerService for Miner {
         }
     }
 
-    fn map_sealing_work<C, F, T>(&self, client: &C, f: F) -> Option<T>
-    where
-        C: AccountData + BlockChainTrait + BlockProducer + ChainTimeInfo + EngineInfo + FindActionHandler + TermInfo,
-        F: FnOnce(&ClosedBlock) -> T, {
-        ctrace!(MINER, "map_sealing_work: entering");
-        self.prepare_work_sealing(client);
-        ctrace!(MINER, "map_sealing_work: sealing prepared");
-        let mut sealing_work = self.sealing_work.lock();
-        let ret = sealing_work.queue.use_last_ref();
-        ctrace!(MINER, "map_sealing_work: leaving use_last_ref={:?}", ret.as_ref().map(|b| b.block().header().hash()));
-        ret.map(f)
-    }
-
     fn import_external_transactions<C: MiningBlockChainClient + EngineInfo + TermInfo>(
         &self,
         client: &C,

core/src/miner/mod.rs

@@ -36,7 +36,6 @@ pub use self::mem_pool_types::MemPoolFees;
 pub use self::miner::{AuthoringParams, Miner, MinerOptions};
 pub use self::stratum::{Config as StratumConfig, Error as StratumError, Stratum};
 use crate::account_provider::{AccountProvider, Error as AccountProviderError};
-use crate::block::ClosedBlock;
 use crate::client::{
     AccountData, BlockChainTrait, BlockProducer, EngineInfo, ImportBlock, MiningBlockChainClient, TermInfo,
 };
@@ -106,13 +105,6 @@ pub trait MinerService: Send + Sync {
     /// Will check the seal, but not actually insert the block into the chain.
     fn submit_seal<C: ImportBlock>(&self, chain: &C, pow_hash: BlockHash, seal: Vec<Bytes>) -> Result<(), Error>;
 
-    /// Get the sealing work package and if `Some`, apply some transform.
-    fn map_sealing_work<C, F, T>(&self, client: &C, f: F) -> Option<T>
-    where
-        C: AccountData + BlockChainTrait + BlockProducer + ChainTimeInfo + EngineInfo + FindActionHandler + TermInfo,
-        F: FnOnce(&ClosedBlock) -> T,
-        Self: Sized;
-
     /// Imports transactions to mem pool.
     fn import_external_transactions<C: MiningBlockChainClient + EngineInfo + TermInfo>(
         &self,

core/src/miner/sealing_queue.rs

@@ -16,22 +16,17 @@
 
 use crate::block::ClosedBlock;
 
+#[derive(Default)]
 pub struct SealingQueue {
     /// Not yet being sealed by a miner, but if one asks for work, we'd prefer they do this.
     pending: Option<ClosedBlock>,
     /// Currently being sealed by miners.
     in_use: Vec<ClosedBlock>,
-    /// The maximum allowable number of items in_use.
-    max_size: usize,
 }
 
 impl SealingQueue {
-    pub fn new(max_size: usize) -> Self {
-        Self {
-            pending: None,
-            in_use: Vec::new(),
-            max_size,
-        }
+    pub fn new() -> Self {
+        Self::default()
     }
 
     /// Return a reference to the item at the top of the queue (or `None` if the queue is empty);
@@ -50,9 +45,6 @@ impl SealingQueue {
     pub fn use_last_ref(&mut self) -> Option<&ClosedBlock> {
         if let Some(x) = self.pending.take() {
             self.in_use.push(x);
-            if self.in_use.len() > self.max_size {
-                self.in_use.remove(0);
-            }
         }
         self.in_use.last()
     }
@@ -74,8 +66,6 @@ mod tests {
     use crate::scheme::Scheme;
     use crate::tests::helpers::get_temp_state_db;
 
-    const QUEUE_SIZE: usize = 2;
-
     fn create_closed_block(address: Address) -> ClosedBlock {
         let scheme = Scheme::new_test();
         let genesis_header = scheme.genesis_header();
@@ -87,7 +77,7 @@ mod tests {
 
     #[test]
     fn fail_to_find_when_pushed() {
-        let mut q = SealingQueue::new(QUEUE_SIZE);
+        let mut q = SealingQueue::new();
         let b = create_closed_block(Address::default());
         let h = b.hash();
 
@@ -98,7 +88,7 @@ mod tests {
 
     #[test]
     fn find_when_pushed_and_used() {
-        let mut q = SealingQueue::new(QUEUE_SIZE);
+        let mut q = SealingQueue::new();
         let b = create_closed_block(Address::default());
         let h = b.hash();
 
@@ -110,7 +100,7 @@ mod tests {
 
     #[test]
     fn find_when_others_used() {
-        let mut q = SealingQueue::new(QUEUE_SIZE);
+        let mut q = SealingQueue::new();
         let b1 = create_closed_block(Address::from(1));
         let b2 = create_closed_block(Address::from(2));
         let h1 = b1.hash();
@@ -123,24 +113,9 @@ mod tests {
         assert!(q.take_used_if(|b| b.hash() == h1).is_some());
     }
 
-    #[test]
-    fn fail_to_find_when_too_many_used() {
-        let mut q = SealingQueue::new(1);
-        let b1 = create_closed_block(Address::from(1));
-        let b2 = create_closed_block(Address::from(2));
-        let h1 = b1.hash();
-
-        q.push(b1);
-        q.use_last_ref();
-        q.push(b2);
-        q.use_last_ref();
-
-        assert!(q.take_used_if(|b| b.hash() == h1).is_none());
-    }
-
     #[test]
     fn fail_to_find_when_not_used_and_then_pushed() {
-        let mut q = SealingQueue::new(QUEUE_SIZE);
+        let mut q = SealingQueue::new();
         let b1 = create_closed_block(Address::from(1));
         let b2 = create_closed_block(Address::from(2));
         let h1 = b1.hash();
@@ -154,7 +129,7 @@ mod tests {
 
     #[test]
     fn peek_correctly_after_push() {
-        let mut q = SealingQueue::new(QUEUE_SIZE);
+        let mut q = SealingQueue::new();
         let b1 = create_closed_block(Address::from(1));
         let b2 = create_closed_block(Address::from(2));
         let h1 = b1.hash();
@@ -169,7 +144,7 @@ mod tests {
 
     #[test]
     fn inspect_correctly() {
-        let mut q = SealingQueue::new(QUEUE_SIZE);
+        let mut q = SealingQueue::new();
         let b1 = create_closed_block(Address::from(1));
         let b2 = create_closed_block(Address::from(2));
         let h1 = b1.hash();
@@ -186,7 +161,7 @@ mod tests {
 
     #[test]
     fn fail_to_find_when_not_used_peeked_and_then_pushed() {
-        let mut q = SealingQueue::new(QUEUE_SIZE);
+        let mut q = SealingQueue::new();
         let b1 = create_closed_block(Address::from(1));
         let b2 = create_closed_block(Address::from(2));
         let h = b1.hash();

foundry/config/mod.rs

@@ -107,7 +107,6 @@ impl Config {
             reseal_min_period: Duration::from_millis(self.mining.reseal_min_period.unwrap()),
             reseal_max_period: Duration::from_millis(self.mining.reseal_max_period.unwrap()),
             no_reseal_timer: self.mining.no_reseal_timer.unwrap(),
-            work_queue_size: self.mining.work_queue_size.unwrap(),
             mem_pool_fees,
         })
     }
@@ -245,7 +244,6 @@ pub struct Mining {
     pub reseal_min_period: Option<u64>,
     pub reseal_max_period: Option<u64>,
     pub no_reseal_timer: Option<bool>,
-    pub work_queue_size: Option<usize>,
     pub allowed_past_gap: Option<u64>,
     pub allowed_future_gap: Option<u64>,
     pub min_pay_transaction_cost: Option<u64>,
@@ -439,9 +437,6 @@ impl Mining {
         if other.no_reseal_timer.is_some() {
             self.no_reseal_timer = other.no_reseal_timer;
         }
-        if other.work_queue_size.is_some() {
-            self.work_queue_size = other.work_queue_size;
-        }
         if other.min_pay_transaction_cost.is_some() {
             self.min_pay_transaction_cost = other.min_pay_transaction_cost;
         }
@@ -529,9 +524,6 @@ impl Mining {
         if matches.is_present("no-reseal-timer") {
             self.no_reseal_timer = Some(true);
         }
-        if let Some(work_queue_size) = matches.value_of("work-queue-size") {
-            self.work_queue_size = Some(work_queue_size.parse().map_err(|_| "Invalid size")?);
-        }
         if let Some(allowed_past_gap) = matches.value_of("allowed-past-gap") {
             self.allowed_past_gap = Some(allowed_past_gap.parse().map_err(|_| "Invalid time gap")?);
         }

foundry/config/presets/config.dev.toml

@@ -14,7 +14,6 @@ reseal_on_txs = "all"
 reseal_min_period = 0
 reseal_max_period = 120000
 no_reseal_timer = false
-work_queue_size = 20
 allowed_past_gap = 30000
 allowed_future_gap = 5000
 

foundry/config/presets/config.prod.toml

@@ -14,7 +14,6 @@ reseal_on_txs = "all"
 reseal_min_period = 4000
 reseal_max_period = 120000
 no_reseal_timer = false
-work_queue_size = 20
 allowed_past_gap = 30000
 allowed_future_gap = 5000