Cache the total points tracked in our historical liquidity data

When we go to score a channel using the historical liquidity data,
the first thing we do is step through all the valid bucket
combinations, multiply the min and max bucket, and then add them
together to calculate the total number of points tracked. This
isn't a free operation, and for scorers without much data it
represents a large part of the total time spent scoring during
routefinding.

Thus, here we cache this value, updating it every time the buckets
are updated.

diff --git a/lightning/src/routing/scoring.rs b/lightning/src/routing/scoring.rs
index 4ba1977db0ffacb92ff13b06521e194111ad6bea..277f1213f17a4f7d36ca18fcfda51c505d47d944 100644 (file)
--- a/lightning/src/routing/scoring.rs
+++ b/lightning/src/routing/scoring.rs
@@ -1631,6 +1631,7 @@ mod bucketed_history {
        pub(super) struct HistoricalLiquidityTracker {
                min_liquidity_offset_history: HistoricalBucketRangeTracker,
                max_liquidity_offset_history: HistoricalBucketRangeTracker,
+               total_valid_points_tracked: u64,
        }
 
        impl HistoricalLiquidityTracker {
@@ -1638,6 +1639,7 @@ mod bucketed_history {
                        HistoricalLiquidityTracker {
                                min_liquidity_offset_history: HistoricalBucketRangeTracker::new(),
                                max_liquidity_offset_history: HistoricalBucketRangeTracker::new(),
+                               total_valid_points_tracked: 0,
                        }
                }
 
@@ -1645,10 +1647,13 @@ mod bucketed_history {
                        min_liquidity_offset_history: HistoricalBucketRangeTracker,
                        max_liquidity_offset_history: HistoricalBucketRangeTracker,
                ) -> HistoricalLiquidityTracker {
-                       HistoricalLiquidityTracker {
+                       let mut res = HistoricalLiquidityTracker {
                                min_liquidity_offset_history,
                                max_liquidity_offset_history,
-                       }
+                               total_valid_points_tracked: 0,
+                       };
+                       res.recalculate_valid_points();
+                       res
                }
 
                pub(super) fn has_datapoints(&self) -> bool {
@@ -1664,6 +1669,16 @@ mod bucketed_history {
                        for bucket in self.max_liquidity_offset_history.buckets.iter_mut() {
                                *bucket = ((*bucket as u64) * 1024 / divisor) as u16;
                        }
+                       self.recalculate_valid_points();
+               }
+
+               fn recalculate_valid_points(&mut self) {
+                       self.total_valid_points_tracked = 0;
+                       for (min_idx, min_bucket) in self.min_liquidity_offset_history.buckets.iter().enumerate() {
+                               for max_bucket in self.max_liquidity_offset_history.buckets.iter().take(32 - min_idx) {
+                                       self.total_valid_points_tracked += (*min_bucket as u64) * (*max_bucket as u64);
+                               }
+                       }
                }
 
                pub(super) fn writeable_min_offset_history(&self) -> &HistoricalBucketRangeTracker {
@@ -1703,6 +1718,7 @@ mod bucketed_history {
                                self.tracker.max_liquidity_offset_history.track_datapoint(min_offset_msat, capacity_msat);
                                self.tracker.min_liquidity_offset_history.track_datapoint(max_offset_msat, capacity_msat);
                        }
+                       self.tracker.recalculate_valid_points();
                }
        }
 
@@ -1743,11 +1759,15 @@ mod bucketed_history {
                        let max_liquidity_offset_history_buckets =
                                self.max_liquidity_offset_history_buckets();
 
-                       let mut total_valid_points_tracked = 0;
-                       for (min_idx, min_bucket) in min_liquidity_offset_history_buckets.iter().enumerate() {
-                               for max_bucket in max_liquidity_offset_history_buckets.iter().take(32 - min_idx) {
-                                       total_valid_points_tracked += (*min_bucket as u64) * (*max_bucket as u64);
+                       let total_valid_points_tracked = self.tracker.total_valid_points_tracked;
+                       #[cfg(debug_assertions)] {
+                               let mut actual_valid_points_tracked = 0;
+                               for (min_idx, min_bucket) in min_liquidity_offset_history_buckets.iter().enumerate() {
+                                       for max_bucket in max_liquidity_offset_history_buckets.iter().take(32 - min_idx) {
+                                               actual_valid_points_tracked += (*min_bucket as u64) * (*max_bucket as u64);
+                                       }
                                }
+                               assert_eq!(total_valid_points_tracked, actual_valid_points_tracked);
                        }
 
                        // If the total valid points is smaller than 1.0 (i.e. 32 in our fixed-point scheme),