f wrap

Author: TheBlueMatt

lightning/src/routing/scoring.rs

@@ -433,6 +433,28 @@ pub struct ProbabilisticScoringParameters {
 	pub considered_impossible_penalty_msat: u64,
 }
 
+/// Tracks the historical state of a distribution as a weighted average of how much time was spent
+/// in each of 8 buckets.
+#[derive(Clone, Copy)]
+struct HistoricalBucketRangeTracker {
+	buckets: [u16; 8],
+}
+
+impl HistoricalBucketRangeTracker {
+	fn new() -> Self { Self { buckets: [0; 8] } }
+	fn track_datapoint(&mut self, bucket: u8) {
+		debug_assert!(bucket < 8);
+		if let Some(v) = self.buckets.get_mut(bucket as usize) {
+			*v = v.saturating_add(8);
+			for e in self.buckets.iter_mut() {
+				*e = ((*e as u64) * 2047 / 2048) as u16;
+			}
+		}
+	}
+}
+
+impl_writeable_tlv_based!(HistoricalBucketRangeTracker, { (0, buckets, required) });
+
 /// Accounting for channel liquidity balance uncertainty.
 ///
 /// Direction is defined in terms of [`NodeId`] partial ordering, where the source node is the
@@ -448,17 +470,17 @@ struct ChannelLiquidity<T: Time> {
 	/// Time when the liquidity bounds were last modified.
 	last_updated: T,
 
-	min_liquidity_offset_history: [u16; 8],
-	max_liquidity_offset_history: [u16; 8],
+	min_liquidity_offset_history: HistoricalBucketRangeTracker,
+	max_liquidity_offset_history: HistoricalBucketRangeTracker,
 }
 
 /// A snapshot of [`ChannelLiquidity`] in one direction assuming a certain channel capacity and
 /// decayed with a given half life.
-struct DirectedChannelLiquidity<L: Deref<Target = u64>, LA: Deref<Target = [u16; 8]>, T: Time, U: Deref<Target = T>> {
+struct DirectedChannelLiquidity<L: Deref<Target = u64>, BRT: Deref<Target = HistoricalBucketRangeTracker>, T: Time, U: Deref<Target = T>> {
 	min_liquidity_offset_msat: L,
 	max_liquidity_offset_msat: L,
-	min_liquidity_offset_history: LA,
-	max_liquidity_offset_history: LA,
+	min_liquidity_offset_history: BRT,
+	max_liquidity_offset_history: BRT,
 	capacity_msat: u64,
 	last_updated: U,
 	now: T,
@@ -599,8 +621,8 @@ impl<T: Time> ChannelLiquidity<T> {
 		Self {
 			min_liquidity_offset_msat: 0,
 			max_liquidity_offset_msat: 0,
-			min_liquidity_offset_history: [0; 8],
-			max_liquidity_offset_history: [0; 8],
+			min_liquidity_offset_history: HistoricalBucketRangeTracker::new(),
+			max_liquidity_offset_history: HistoricalBucketRangeTracker::new(),
 			last_updated: T::now(),
 		}
 	}
@@ -609,7 +631,7 @@ impl<T: Time> ChannelLiquidity<T> {
 	/// `capacity_msat`.
 	fn as_directed(
 		&self, source: &NodeId, target: &NodeId, capacity_msat: u64, half_life: Duration
-	) -> DirectedChannelLiquidity<&u64, &[u16; 8], T, &T> {
+	) -> DirectedChannelLiquidity<&u64, &HistoricalBucketRangeTracker, T, &T> {
 		let (min_liquidity_offset_msat, max_liquidity_offset_msat, min_liquidity_offset_history, max_liquidity_offset_history) =
 			if source < target {
 				(&self.min_liquidity_offset_msat, &self.max_liquidity_offset_msat,
@@ -635,7 +657,7 @@ impl<T: Time> ChannelLiquidity<T> {
 	/// `capacity_msat`.
 	fn as_directed_mut(
 		&mut self, source: &NodeId, target: &NodeId, capacity_msat: u64, half_life: Duration
-	) -> DirectedChannelLiquidity<&mut u64, &mut [u16; 8], T, &mut T> {
+	) -> DirectedChannelLiquidity<&mut u64, &mut HistoricalBucketRangeTracker, T, &mut T> {
 		let (min_liquidity_offset_msat, max_liquidity_offset_msat, min_liquidity_offset_history, max_liquidity_offset_history) =
 			if source < target {
 				(&mut self.min_liquidity_offset_msat, &mut self.max_liquidity_offset_msat,
@@ -670,7 +692,7 @@ const PRECISION_LOWER_BOUND_DENOMINATOR: u64 = approx::LOWER_BITS_BOUND;
 const AMOUNT_PENALTY_DIVISOR: u64 = 1 << 20;
 const BASE_AMOUNT_PENALTY_DIVISOR: u64 = 1 << 30;
 
-impl<L: Deref<Target = u64>, LA: Deref<Target = [u16; 8]>, T: Time, U: Deref<Target = T>> DirectedChannelLiquidity<L, LA, T, U> {
+impl<L: Deref<Target = u64>, BRT: Deref<Target = HistoricalBucketRangeTracker>, T: Time, U: Deref<Target = T>> DirectedChannelLiquidity<L, BRT, T, U> {
 	/// Returns a liquidity penalty for routing the given HTLC `amount_msat` through the channel in
 	/// this direction.
 	fn penalty_msat(&self, amount_msat: u64, params: &ProbabilisticScoringParameters) -> u64 {
@@ -740,7 +762,7 @@ impl<L: Deref<Target = u64>, LA: Deref<Target = [u16; 8]>, T: Time, U: Deref<Tar
 	}
 }
 
-impl<L: DerefMut<Target = u64>, LA: DerefMut<Target = [u16; 8]>, T: Time, U: DerefMut<Target = T>> DirectedChannelLiquidity<L, LA, T, U> {
+impl<L: DerefMut<Target = u64>, BRT: DerefMut<Target = HistoricalBucketRangeTracker>, T: Time, U: DerefMut<Target = T>> DirectedChannelLiquidity<L, BRT, T, U> {
 	/// Adjusts the channel liquidity balance bounds when failing to route `amount_msat`.
 	fn failed_at_channel<Log: Deref>(&mut self, amount_msat: u64, chan_descr: fmt::Arguments, logger: &Log) where Log::Target: Logger {
 		if amount_msat < self.max_liquidity_msat() {
@@ -782,25 +804,13 @@ impl<L: DerefMut<Target = u64>, LA: DerefMut<Target = [u16; 8]>, T: Time, U: Der
 		// In total, this allows us to track data for the last 8,000 or so payments across a given
 		// channel.
 		debug_assert!(*self.min_liquidity_offset_msat <= self.capacity_msat);
-		if let Some(v) = self.min_liquidity_offset_history
-			.get_mut((self.min_liquidity_offset_msat.saturating_sub(1) * 8 / self.capacity_msat)
-				.try_into().unwrap_or(32))
-		{
-			*v = v.saturating_add(8);
-			for e in self.min_liquidity_offset_history.iter_mut() {
-				*e = ((*e as u64) * 2047 / 2048) as u16;
-			}
-		}
+		self.min_liquidity_offset_history.track_datapoint(
+			(self.min_liquidity_offset_msat.saturating_sub(1) * 8 / self.capacity_msat)
+			.try_into().unwrap_or(32)); // 32 is bogus for 8 buckets, and will be ignored
 		debug_assert!(*self.max_liquidity_offset_msat <= self.capacity_msat);
-		if let Some(v) = self.max_liquidity_offset_history
-			.get_mut((self.max_liquidity_offset_msat.saturating_sub(1) * 8 / self.capacity_msat)
-				.try_into().unwrap_or(32))
-		{
-			*v = v.saturating_add(8);
-			for e in self.max_liquidity_offset_history.iter_mut() {
-				*e = ((*e as u64) * 2047 / 2048) as u16;
-			}
-		}
+		self.max_liquidity_offset_history.track_datapoint(
+			(self.max_liquidity_offset_msat.saturating_sub(1) * 8 / self.capacity_msat)
+			.try_into().unwrap_or(32)); // 32 is bogus for 8 buckets, and will be ignored
 	}
 
 	/// Adjusts the lower bound of the channel liquidity balance in this direction.
@@ -1305,8 +1315,8 @@ impl<T: Time> Readable for ChannelLiquidity<T> {
 	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 		let mut min_liquidity_offset_msat = 0;
 		let mut max_liquidity_offset_msat = 0;
-		let mut min_liquidity_offset_history = Some([0; 8]);
-		let mut max_liquidity_offset_history = Some([0; 8]);
+		let mut min_liquidity_offset_history = Some(HistoricalBucketRangeTracker::new());
+		let mut max_liquidity_offset_history = Some(HistoricalBucketRangeTracker::new());
 		let mut duration_since_epoch = Duration::from_secs(0);
 		read_tlv_fields!(r, {
 			(0, min_liquidity_offset_msat, required),
@@ -1339,7 +1349,7 @@ impl<T: Time> Readable for ChannelLiquidity<T> {
 
 #[cfg(test)]
 mod tests {
-	use super::{ChannelLiquidity, ProbabilisticScoringParameters, ProbabilisticScorerUsingTime};
+	use super::{ChannelLiquidity, HistoricalBucketRangeTracker, ProbabilisticScoringParameters, ProbabilisticScorerUsingTime};
 	use util::time::Time;
 	use util::time::tests::SinceEpoch;
 
@@ -1523,12 +1533,14 @@ mod tests {
 			.with_channel(42,
 				ChannelLiquidity {
 					min_liquidity_offset_msat: 700, max_liquidity_offset_msat: 100, last_updated,
-					min_liquidity_offset_history: [0; 8], max_liquidity_offset_history: [0; 8],
+					min_liquidity_offset_history: HistoricalBucketRangeTracker::new(),
+					max_liquidity_offset_history: HistoricalBucketRangeTracker::new(),
 				})
 			.with_channel(43,
 				ChannelLiquidity {
 					min_liquidity_offset_msat: 700, max_liquidity_offset_msat: 100, last_updated,
-					min_liquidity_offset_history: [0; 8], max_liquidity_offset_history: [0; 8],
+					min_liquidity_offset_history: HistoricalBucketRangeTracker::new(),
+					max_liquidity_offset_history: HistoricalBucketRangeTracker::new(),
 				});
 		let source = source_node_id();
 		let target = target_node_id();
@@ -1600,7 +1612,8 @@ mod tests {
 			.with_channel(42,
 				ChannelLiquidity {
 					min_liquidity_offset_msat: 200, max_liquidity_offset_msat: 400, last_updated,
-					min_liquidity_offset_history: [0; 8], max_liquidity_offset_history: [0; 8],
+					min_liquidity_offset_history: HistoricalBucketRangeTracker::new(),
+					max_liquidity_offset_history: HistoricalBucketRangeTracker::new(),
 				});
 		let source = source_node_id();
 		let target = target_node_id();
@@ -1659,7 +1672,8 @@ mod tests {
 			.with_channel(42,
 				ChannelLiquidity {
 					min_liquidity_offset_msat: 200, max_liquidity_offset_msat: 400, last_updated,
-					min_liquidity_offset_history: [0; 8], max_liquidity_offset_history: [0; 8],
+					min_liquidity_offset_history: HistoricalBucketRangeTracker::new(),
+					max_liquidity_offset_history: HistoricalBucketRangeTracker::new(),
 				});
 		let source = source_node_id();
 		let target = target_node_id();
@@ -1767,7 +1781,8 @@ mod tests {
 			.with_channel(42,
 				ChannelLiquidity {
 					min_liquidity_offset_msat: 40, max_liquidity_offset_msat: 40, last_updated,
-					min_liquidity_offset_history: [0; 8], max_liquidity_offset_history: [0; 8],
+					min_liquidity_offset_history: HistoricalBucketRangeTracker::new(),
+					max_liquidity_offset_history: HistoricalBucketRangeTracker::new(),
 				});
 		let source = source_node_id();
 		let target = target_node_id();