Change priority bucket expected time to block target time (kaspanet#735)

* change priority bucket expected time to block target time

* clippy

---------

Co-authored-by: coderofstuff <[email protected]>

Author: someone235

mining/benches/bench.rs

@@ -102,7 +102,7 @@ pub fn bench_mempool_sampling(c: &mut Criterion) {
     }
 
     let len = cap;
-    let mut frontier = Frontier::default();
+    let mut frontier = Frontier::new(1.0);
     for item in map.values().take(len).cloned() {
         frontier.insert(item).then_some(()).unwrap();
     }
@@ -183,7 +183,7 @@ pub fn bench_mempool_selectors(c: &mut Criterion) {
     }
 
     for len in [100, 300, 350, 500, 1000, 2000, 5000, 10_000, 100_000, 500_000, 1_000_000].into_iter().rev() {
-        let mut frontier = Frontier::default();
+        let mut frontier = Frontier::new(1.0);
         for item in map.values().take(len).cloned() {
             frontier.insert(item).then_some(()).unwrap();
         }
@@ -252,7 +252,7 @@ pub fn bench_inplace_sampling_worst_case(c: &mut Criterion) {
             map.insert(key.tx.id(), key);
         }
 
-        let mut frontier = Frontier::default();
+        let mut frontier = Frontier::new(1.0);
         for item in map.values().cloned() {
             frontier.insert(item).then_some(()).unwrap();
         }

mining/src/feerate/mod.rs

@@ -85,13 +85,15 @@ pub struct FeerateEstimator {
     /// other words, the inverse of the transaction inclusion rate. For instance, if the average transaction mass is 2500 grams,
     /// the block mass limit is 500,000 and the network has 10 BPS, then this number would be 1/2000 seconds.
     inclusion_interval: f64,
+
+    target_time_per_block_seconds: f64,
 }
 
 impl FeerateEstimator {
-    pub fn new(total_weight: f64, inclusion_interval: f64) -> Self {
+    pub fn new(total_weight: f64, inclusion_interval: f64, target_time_per_block_seconds: f64) -> Self {
         assert!(total_weight >= 0.0);
         assert!((0f64..1f64).contains(&inclusion_interval));
-        Self { total_weight, inclusion_interval }
+        Self { total_weight, inclusion_interval, target_time_per_block_seconds }
     }
 
     pub(crate) fn feerate_to_time(&self, feerate: f64) -> f64 {
@@ -132,8 +134,8 @@ impl FeerateEstimator {
 
     pub fn calc_estimations(&self, minimum_standard_feerate: f64) -> FeerateEstimations {
         let min = minimum_standard_feerate;
-        // Choose `high` such that it provides sub-second waiting time
-        let high = self.time_to_feerate(1f64).max(min);
+        // Choose `high` such that the transaction is expected to be included in the next block.
+        let high = self.time_to_feerate(self.target_time_per_block_seconds).max(min);
         // Choose `low` feerate such that it provides sub-hour waiting time AND it covers (at least) the 0.25 quantile
         let low = self.time_to_feerate(3600f64).max(self.quantile(min, high, 0.25));
         // Choose `normal` feerate such that it provides sub-minute waiting time AND it covers (at least) the 0.66 quantile between low and high.
@@ -176,7 +178,8 @@ mod tests {
 
     #[test]
     fn test_feerate_estimations() {
-        let estimator = FeerateEstimator { total_weight: 1002283.659, inclusion_interval: 0.004f64 };
+        let estimator =
+            FeerateEstimator { total_weight: 1002283.659, inclusion_interval: 0.004f64, target_time_per_block_seconds: 1.0 };
         let estimations = estimator.calc_estimations(1.0);
         let buckets = estimations.ordered_buckets();
         for (i, j) in buckets.into_iter().tuple_windows() {
@@ -187,7 +190,7 @@ mod tests {
 
     #[test]
     fn test_min_feerate_estimations() {
-        let estimator = FeerateEstimator { total_weight: 0.00659, inclusion_interval: 0.004f64 };
+        let estimator = FeerateEstimator { total_weight: 0.00659, inclusion_interval: 0.004f64, target_time_per_block_seconds: 1.0 };
         let minimum_feerate = 0.755;
         let estimations = estimator.calc_estimations(minimum_feerate);
         println!("{estimations}");
@@ -201,7 +204,7 @@ mod tests {
 
     #[test]
     fn test_zero_values() {
-        let estimator = FeerateEstimator { total_weight: 0.0, inclusion_interval: 0.0 };
+        let estimator = FeerateEstimator { total_weight: 0.0, inclusion_interval: 0.0, target_time_per_block_seconds: 1.0 };
         let minimum_feerate = 0.755;
         let estimations = estimator.calc_estimations(minimum_feerate);
         let buckets = estimations.ordered_buckets();
@@ -210,7 +213,7 @@ mod tests {
             assert_eq!(0.0, bucket.estimated_seconds);
         }
 
-        let estimator = FeerateEstimator { total_weight: 0.0, inclusion_interval: 0.1 };
+        let estimator = FeerateEstimator { total_weight: 0.0, inclusion_interval: 0.1, target_time_per_block_seconds: 1.0 };
         let minimum_feerate = 0.755;
         let estimations = estimator.calc_estimations(minimum_feerate);
         let buckets = estimations.ordered_buckets();
@@ -219,7 +222,7 @@ mod tests {
             assert_eq!(estimator.inclusion_interval, bucket.estimated_seconds);
         }
 
-        let estimator = FeerateEstimator { total_weight: 0.1, inclusion_interval: 0.0 };
+        let estimator = FeerateEstimator { total_weight: 0.1, inclusion_interval: 0.0, target_time_per_block_seconds: 1.0 };
         let minimum_feerate = 0.755;
         let estimations = estimator.calc_estimations(minimum_feerate);
         let buckets = estimations.ordered_buckets();

mining/src/mempool/model/frontier.rs

@@ -43,11 +43,18 @@ pub struct Frontier {
 
     /// Tracks the average transaction mass throughout the mempool's lifespan using a decayed weighting mechanism
     average_transaction_mass: f64,
+
+    target_time_per_block_seconds: f64,
 }
 
-impl Default for Frontier {
-    fn default() -> Self {
-        Self { search_tree: Default::default(), total_mass: Default::default(), average_transaction_mass: INITIAL_AVG_MASS }
+impl Frontier {
+    pub fn new(target_time_per_block_seconds: f64) -> Self {
+        Self {
+            search_tree: Default::default(),
+            total_mass: Default::default(),
+            average_transaction_mass: INITIAL_AVG_MASS,
+            target_time_per_block_seconds,
+        }
     }
 }
 
@@ -229,7 +236,7 @@ impl Frontier {
         let bps = args.network_blocks_per_second as f64;
         let mut mass_per_block = args.maximum_mass_per_block as f64;
         let mut inclusion_interval = average_transaction_mass / (mass_per_block * bps);
-        let mut estimator = FeerateEstimator::new(self.total_weight(), inclusion_interval);
+        let mut estimator = FeerateEstimator::new(self.total_weight(), inclusion_interval, self.target_time_per_block_seconds);
 
         // Search for better estimators by possibly removing extremely high outliers
         let mut down_iter = self.search_tree.descending_iter().peekable();
@@ -250,7 +257,7 @@ impl Frontier {
 
             // Compute the weight up to, and excluding, current key (which translates to zero weight if peek() is none)
             let prefix_weight = down_iter.peek().map(|key| self.search_tree.prefix_weight(key)).unwrap_or_default();
-            let pending_estimator = FeerateEstimator::new(prefix_weight, inclusion_interval);
+            let pending_estimator = FeerateEstimator::new(prefix_weight, inclusion_interval, self.target_time_per_block_seconds);
 
             // Test the pending estimator vs. the current one
             if pending_estimator.feerate_to_time(1.0) < estimator.feerate_to_time(1.0) {
@@ -294,7 +301,7 @@ mod tests {
             map.insert(key.tx.id(), key);
         }
 
-        let mut frontier = Frontier::default();
+        let mut frontier = Frontier::new(1.0);
         for item in map.values().cloned() {
             frontier.insert(item).then_some(()).unwrap();
         }
@@ -314,7 +321,7 @@ mod tests {
             map.insert(key.tx.id(), key);
         }
 
-        let mut frontier = Frontier::default();
+        let mut frontier = Frontier::new(1.0);
         for item in map.values().cloned() {
             frontier.insert(item).then_some(()).unwrap();
         }
@@ -348,7 +355,7 @@ mod tests {
         }
 
         let len = cap / 2;
-        let mut frontier = Frontier::default();
+        let mut frontier = Frontier::new(1.0);
         for item in map.values().take(len).cloned() {
             frontier.insert(item).then_some(()).unwrap();
         }
@@ -402,7 +409,7 @@ mod tests {
         }
 
         for len in [0, 1, 10, 100, 200, 300, 500, 750, cap / 2, (cap * 2) / 3, (cap * 4) / 5, (cap * 5) / 6, cap] {
-            let mut frontier = Frontier::default();
+            let mut frontier = Frontier::new(1.0);
             for item in map.values().take(len).cloned() {
                 frontier.insert(item).then_some(()).unwrap();
             }
@@ -444,7 +451,7 @@ mod tests {
         for len in [0, 1, 10, 100, 200, 300, 500, 750, cap / 2, (cap * 2) / 3, (cap * 4) / 5, (cap * 5) / 6, cap] {
             println!();
             println!("Testing a frontier with {} txs...", len.min(cap));
-            let mut frontier = Frontier::default();
+            let mut frontier = Frontier::new(1.0);
             for item in map.values().take(len).cloned() {
                 frontier.insert(item).then_some(()).unwrap();
             }
@@ -477,7 +484,7 @@ mod tests {
         const HIGH_FEERATE: f64 = 1000.0;
 
         let cap = 20_000;
-        let mut frontier = Frontier::default();
+        let mut frontier = Frontier::new(1.0);
         for i in 0..cap as u64 {
             let (mass, fee) = if i < 200 {
                 let mass = 1650;
@@ -533,7 +540,7 @@ mod tests {
 
         // All lens make for less than block capacity (given the mass used)
         for len in [0, 1, 10, 100, 200, 250, 300] {
-            let mut frontier = Frontier::default();
+            let mut frontier = Frontier::new(1.0);
             for item in map.values().take(len).cloned() {
                 frontier.insert(item).then_some(()).unwrap();
             }

mining/src/mempool/model/transactions_pool.rs

@@ -81,12 +81,14 @@ pub(crate) struct TransactionsPool {
 
 impl TransactionsPool {
     pub(crate) fn new(config: Arc<Config>) -> Self {
+        // [Crescendo] Delete `after()` after cleanup.
+        let target_time_per_block = 1.0 / (config.network_blocks_per_second.after() as f64);
         Self {
             config,
             all_transactions: MempoolTransactionCollection::default(),
             parent_transactions: TransactionsEdges::default(),
             chained_transactions: TransactionsEdges::default(),
-            ready_transactions: Default::default(),
+            ready_transactions: Frontier::new(target_time_per_block),
             last_expire_scan_daa_score: 0,
             last_expire_scan_time: unix_now(),
             utxo_set: MempoolUtxoSet::new(),