split single lock into write and read lock

Author: jbesraa

lightning-background-processor/src/lib.rs

@@ -241,7 +241,7 @@ fn handle_network_graph_update<L: Deref>(
 fn update_scorer<'a, S: 'static + Deref<Target = SC> + Send + Sync, SC: 'a + WriteableScore<'a>>(
 	scorer: &'a S, event: &Event
 ) -> bool {
-	let mut score = scorer.lock();
+	let mut score = scorer.write_lock();
 	match event {
 		Event::PaymentPathFailed { ref path, short_channel_id: Some(scid), .. } => {
 			score.payment_path_failed(path, *scid);

lightning/src/routing/router.rs

@@ -27,7 +27,7 @@ use crate::util::chacha20::ChaCha20;
 
 use crate::io;
 use crate::prelude::*;
-use crate::sync::{Mutex};
+use crate::sync::Mutex;
 use alloc::collections::BinaryHeap;
 use core::{cmp, fmt};
 use core::ops::{Deref, DerefMut};
@@ -73,7 +73,7 @@ impl< G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref, SP: Sized, Sc: Sco
 		};
 		find_route(
 			payer, params, &self.network_graph, first_hops, &*self.logger,
-			&ScorerAccountingForInFlightHtlcs::new(self.scorer.lock().deref_mut(), inflight_htlcs),
+			&ScorerAccountingForInFlightHtlcs::new(self.scorer.write_lock().deref_mut(), inflight_htlcs),
 			&self.score_params,
 			&random_seed_bytes
 		)

lightning/src/routing/scoring.rs

@@ -65,7 +65,7 @@ use crate::util::time::Time;
 
 use crate::prelude::*;
 use core::{cmp, fmt};
-use core::cell::{RefCell, RefMut};
+use core::cell::{RefCell, RefMut, Ref};
 use core::convert::TryInto;
 use core::ops::{Deref, DerefMut};
 use core::time::Duration;
@@ -145,6 +145,7 @@ impl<S: Score, T: DerefMut<Target=S> $(+ $supertrait)*> Score for T {
 
 #[cfg(c_bindings)]
 define_score!(Writeable);
+
 #[cfg(not(c_bindings))]
 define_score!();
 
@@ -160,11 +161,17 @@ pub trait LockableScore<'a> {
 	/// The [`Score`] type.
 	type Score: 'a + Score;
 
-	/// The locked [`Score`] type.
-	type Locked: DerefMut<Target = Self::Score> + Sized;
+	/// The Write locked [`Score`] type.
+	type WriteLocked: DerefMut<Target = Self::Score> + Sized;
+
+	/// The Read locked [`Score`] type.
+	type ReadLocked: Deref<Target = Self::Score> + Sized;
+
+	/// Returns read locked scorer.
+	fn read_lock(&'a self) -> Self::ReadLocked;
 
-	/// Returns the locked scorer.
-	fn lock(&'a self) -> Self::Locked;
+	/// Returns write locked scorer.
+	fn write_lock(&'a self) -> Self::WriteLocked;
 }
 
 /// Refers to a scorer that is accessible under lock and also writeable to disk
@@ -178,20 +185,30 @@ impl<'a, T> WriteableScore<'a> for T where T: LockableScore<'a> + Writeable {}
 /// This is not exported to bindings users
 impl<'a, T: 'a + Score> LockableScore<'a> for Mutex<T> {
 	type Score = T;
-	type Locked = MutexGuard<'a, T>;
+	type WriteLocked = MutexGuard<'a, T>;
+	type ReadLocked = MutexGuard<'a, T>;
+
+	fn read_lock(&'a self) -> Self::ReadLocked {
+		Mutex::lock(self).unwrap()
+	}
 
-	fn lock(&'a self) -> Self::Locked {
+	fn write_lock(&'a self) -> Self::WriteLocked {
 		Mutex::lock(self).unwrap()
 	}
 }
 
 impl<'a, T: 'a + Score> LockableScore<'a> for RefCell<T> {
 	type Score = T;
-	type Locked = RefMut<'a, T>;
+	type WriteLocked = RefMut<'a, T>;
+	type ReadLocked = Ref<'a, T>;
 
-	fn lock(&'a self) -> Self::Locked {
+	fn write_lock(&'a self) -> Self::WriteLocked {
 		self.borrow_mut()
 	}
+
+	fn read_lock(&'a self) -> Self::ReadLocked {
+		self.borrow()
+	}
 }
 
 #[cfg(c_bindings)]
@@ -203,17 +220,22 @@ pub struct MultiThreadedLockableScore<T: Score> {
 #[cfg(c_bindings)]
 impl<'a, T: 'a + Score> LockableScore<'a> for MultiThreadedLockableScore<T> {
 	type Score = T;
-	type Locked = MultiThreadedScoreLock<'a, T>;
+	type ReadLocked = MultiThreadedScoreLock<'a, T>;
+	type WriteLocked = MultiThreadedScoreLock<'a, T>;
+
+	fn read_lock(&'a self) -> Self::WriteLocked {
+		MultiThreadedScoreLock(Mutex::lock(&self.score).unwrap())
+	}
 
-	fn lock(&'a self) -> Self::Locked {
+	fn write_lock(&'a self) -> Self::ReadLocked {
 		MultiThreadedScoreLock(Mutex::lock(&self.score).unwrap())
 	}
 }
 
 #[cfg(c_bindings)]
 impl<T: Score> Writeable for MultiThreadedLockableScore<T> {
 	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
-		self.lock().write(writer)
+		self.score.lock().unwrap().write(writer)
 	}
 }