fix c-binding impls

Author: jbesraa

lightning/src/routing/router.rs

@@ -6797,7 +6797,7 @@ pub(crate) mod bench_utils {
 				let amt = starting_amount + seed % 1_000_000;
 				let path_exists =
 					get_route(&payer, &params, &graph.read_only(), Some(&[&first_hop]),
-						amt, &TestLogger::new(), &scorer, score_params, &random_seed_bytes).is_ok();
+						amt, &TestLogger::new(), scorer, score_params, &random_seed_bytes).is_ok();
 				if path_exists {
 					// ...and seed the scorer with success and failure data...
 					seed = seed.overflowing_mul(6364136223846793005).0.overflowing_add(1).0;
@@ -6811,7 +6811,7 @@ pub(crate) mod bench_utils {
 							.with_bolt11_features(mpp_features).unwrap();
 
 						let route_res = get_route(&payer, &params, &graph.read_only(),
-							Some(&[&first_hop]), score_amt, &TestLogger::new(), &scorer,
+							Some(&[&first_hop]), score_amt, &TestLogger::new(), scorer,
 							score_params, &random_seed_bytes);
 						if let Ok(route) = route_res {
 							for path in route.paths {
@@ -6840,7 +6840,7 @@ pub(crate) mod bench_utils {
 		// requires a too-high CLTV delta.
 		route_endpoints.retain(|(first_hop, params, amt)| {
 			get_route(&payer, params, &graph.read_only(), Some(&[first_hop]), *amt,
-				&TestLogger::new(), &scorer, score_params, &random_seed_bytes).is_ok()
+				&TestLogger::new(), scorer, score_params, &random_seed_bytes).is_ok()
 		});
 		route_endpoints.truncate(route_count);
 		assert_eq!(route_endpoints.len(), route_count);

lightning/src/routing/scoring.rs

@@ -70,7 +70,7 @@ use core::convert::TryInto;
 use core::ops::{Deref, DerefMut};
 use core::time::Duration;
 use crate::io::{self, Read};
-use crate::sync::{Mutex, MutexGuard};
+use crate::sync::{Mutex, MutexGuard, RwLock, RwLockReadGuard, RwLockWriteGuard};
 
 /// We define Score ever-so-slightly differently based on whether we are being built for C bindings
 /// or not. For users, `LockableScore` must somehow be writeable to disk. For Rust users, this is
@@ -211,31 +211,47 @@ impl<'a, T: 'a + Score> LockableScore<'a> for RefCell<T> {
 	}
 }
 
+impl<'a, T: 'a + Score> LockableScore<'a> for RwLock<T> {
+	type Score = T;
+	type WriteLocked = RwLockWriteGuard<'a, T>;
+	type ReadLocked = RwLockReadGuard<'a, T>;
+
+	fn read_lock(&'a self) -> Self::ReadLocked {
+		RwLock::read(self).unwrap()
+	}
+
+	fn write_lock(&'a self) -> Self::WriteLocked {
+		RwLock::write(self).unwrap()
+	}
+}
+
 #[cfg(c_bindings)]
 /// A concrete implementation of [`LockableScore`] which supports multi-threading.
 pub struct MultiThreadedLockableScore<T: Score> {
-	score: Mutex<T>,
+	score: RwLock<T>,
 }
 
 #[cfg(c_bindings)]
 impl<'a, T: 'a + Score> LockableScore<'a> for MultiThreadedLockableScore<T> {
 	type Score = T;
-	type ReadLocked = MultiThreadedScoreLock<'a, T>;
-	type WriteLocked = MultiThreadedScoreLock<'a, T>;
+	// type ReadLocked = MultiThreadedScoreLock<'a, T>;
+	// type WriteLocked = Rw<'a, T>;
+	type WriteLocked = RwLockWriteGuard<'a, T>;
+	type ReadLocked = RwLockReadGuard<'a, T>;
 
-	fn read_lock(&'a self) -> Self::WriteLocked {
-		MultiThreadedScoreLock(Mutex::lock(&self.score).unwrap())
+	fn read_lock(&'a self) -> Self::ReadLocked {
+		RwLock::read(&self.score).unwrap()
 	}
 
-	fn write_lock(&'a self) -> Self::ReadLocked {
-		MultiThreadedScoreLock(Mutex::lock(&self.score).unwrap())
+	fn write_lock(&'a self) -> Self::WriteLocked {
+		RwLock::write(&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.score.lock().unwrap().write(writer)
+		self.score.read().unwrap().write(writer)
 	}
 }
 
@@ -246,7 +262,7 @@ impl<'a, T: 'a + Score> WriteableScore<'a> for MultiThreadedLockableScore<T> {}
 impl<T: Score> MultiThreadedLockableScore<T> {
 	/// Creates a new [`MultiThreadedLockableScore`] given an underlying [`Score`].
 	pub fn new(score: T) -> Self {
-		MultiThreadedLockableScore { score: Mutex::new(score) }
+		MultiThreadedLockableScore { score: RwLock::new(score) }
 	}
 }