score: Mutex<S>,
}
#[cfg(c_bindings)]
-/// (C-not exported)
+/// A locked `MultiThreadedLockableScore`.
+pub struct MultiThreadedScoreLock<'a, S: Score>(MutexGuard<'a, S>);
+#[cfg(c_bindings)]
+impl<'a, T: Score + 'a> Score for MultiThreadedScoreLock<'a, T> {
+ fn channel_penalty_msat(&self, scid: u64, source: &NodeId, target: &NodeId, usage: ChannelUsage) -> u64 {
+ self.0.channel_penalty_msat(scid, source, target, usage)
+ }
+ fn payment_path_failed(&mut self, path: &[&RouteHop], short_channel_id: u64) {
+ self.0.payment_path_failed(path, short_channel_id)
+ }
+ fn payment_path_successful(&mut self, path: &[&RouteHop]) {
+ self.0.payment_path_successful(path)
+ }
+ fn probe_failed(&mut self, path: &[&RouteHop], short_channel_id: u64) {
+ self.0.probe_failed(path, short_channel_id)
+ }
+ fn probe_successful(&mut self, path: &[&RouteHop]) {
+ self.0.probe_successful(path)
+ }
+}
+#[cfg(c_bindings)]
+impl<'a, T: Score + 'a> Writeable for MultiThreadedScoreLock<'a, T> {
+ fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
+ self.0.write(writer)
+ }
+}
+
+#[cfg(c_bindings)]
impl<'a, T: Score + 'a> LockableScore<'a> for MultiThreadedLockableScore<T> {
- type Locked = MutexGuard<'a, T>;
+ type Locked = MultiThreadedScoreLock<'a, T>;
- fn lock(&'a self) -> MutexGuard<'a, T> {
- Mutex::lock(&self.score).unwrap()
+ fn lock(&'a self) -> MultiThreadedScoreLock<'a, T> {
+ MultiThreadedScoreLock(Mutex::lock(&self.score).unwrap())
}
}
impl<L: DerefMut<Target = u64>, T: Time, U: DerefMut<Target = T>> DirectedChannelLiquidity<L, 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() {
- log_debug!(logger, "Setting max liquidity of {} to {}", chan_descr, amount_msat);
+ let existing_max_msat = self.max_liquidity_msat();
+ if amount_msat < existing_max_msat {
+ log_debug!(logger, "Setting max liquidity of {} from {} to {}", chan_descr, existing_max_msat, amount_msat);
self.set_max_liquidity_msat(amount_msat);
} else {
- log_trace!(logger, "Max liquidity of {} already more than {}", chan_descr, amount_msat);
+ log_trace!(logger, "Max liquidity of {} is {} (already less than or equal to {})",
+ chan_descr, existing_max_msat, amount_msat);
}
}
/// Adjusts the channel liquidity balance bounds when failing to route `amount_msat` downstream.
fn failed_downstream<Log: Deref>(&mut self, amount_msat: u64, chan_descr: fmt::Arguments, logger: &Log) where Log::Target: Logger {
- if amount_msat > self.min_liquidity_msat() {
- log_debug!(logger, "Setting min liquidity of {} to {}", chan_descr, amount_msat);
+ let existing_min_msat = self.min_liquidity_msat();
+ if amount_msat > existing_min_msat {
+ log_debug!(logger, "Setting min liquidity of {} from {} to {}", existing_min_msat, chan_descr, amount_msat);
self.set_min_liquidity_msat(amount_msat);
} else {
- log_trace!(logger, "Min liquidity of {} already less than {}", chan_descr, amount_msat);
+ log_trace!(logger, "Min liquidity of {} is {} (already greater than or equal to {})",
+ chan_descr, existing_min_msat, amount_msat);
}
}