Store source/target `node_counter`s in `DirectionalChannelInfo`

[rust-lightning] / lightning / src / routing / router.rs

diff --git a/lightning/src/routing/router.rs b/lightning/src/routing/router.rs
index b4f7cbb20220d655e002c4eac1aedcaacd232a74..e9cee6b246c0fb23866c0bbc0330b97bd8767680 100644 (file)
--- a/lightning/src/routing/router.rs
+++ b/lightning/src/routing/router.rs
@@ -997,12 +997,7 @@ impl cmp::PartialOrd for RouteGraphNode {
 
 // While RouteGraphNode can be laid out with fewer bytes, performance appears to be improved
 // substantially when it is laid out at exactly 64 bytes.
-//
-// Thus, we use `#[repr(C)]` on the struct to force a suboptimal layout and check that it stays 64
-// bytes here.
-#[cfg(any(ldk_bench, not(any(test, fuzzing))))]
 const _GRAPH_NODE_SMALL: usize = 64 - core::mem::size_of::<RouteGraphNode>();
-#[cfg(any(ldk_bench, not(any(test, fuzzing))))]
 const _GRAPH_NODE_FIXED_SIZE: usize = core::mem::size_of::<RouteGraphNode>() - 64;
 
 /// A wrapper around the various hop representations.
@@ -1179,7 +1174,7 @@ impl<'a> CandidateRouteHop<'a> {
                }
        }
 
-       #[inline]
+       #[inline(always)]
        fn src_node_counter(&self) -> u32 {
                match self {
                        CandidateRouteHop::FirstHop { payer_node_counter, .. } => *payer_node_counter,
@@ -1346,7 +1341,7 @@ fn iter_equal<I1: Iterator, I2: Iterator>(mut iter_a: I1, mut iter_b: I2)
 /// Fee values should be updated only in the context of the whole path, see update_value_and_recompute_fees.
 /// These fee values are useful to choose hops as we traverse the graph "payee-to-payer".
 #[derive(Clone)]
-#[repr(C)] // Force fields to appear in the order we define them.
+#[repr(align(128))]
 struct PathBuildingHop<'a> {
        candidate: CandidateRouteHop<'a>,
        target_node_counter: Option<u32>,
@@ -1370,11 +1365,6 @@ struct PathBuildingHop<'a> {
        /// channel scoring.
        path_penalty_msat: u64,
 
-       // The last 16 bytes are on the next cache line by default in glibc's malloc. Thus, we should
-       // only place fields which are not hot there. Luckily, the next three fields are only read if
-       // we end up on the selected path, and only in the final path layout phase, so we don't care
-       // too much if reading them is slow.
-
        fee_msat: u64,
 
        /// All the fees paid *after* this channel on the way to the destination
@@ -1391,17 +1381,8 @@ struct PathBuildingHop<'a> {
        value_contribution_msat: u64,
 }
 
-// Checks that the entries in the `find_route` `dist` map fit in (exactly) two standard x86-64
-// cache lines. Sadly, they're not guaranteed to actually lie on a cache line (and in fact,
-// generally won't, because at least glibc's malloc will align to a nice, big, round
-// boundary...plus 16), but at least it will reduce the amount of data we'll need to load.
-//
-// Note that these assertions only pass on somewhat recent rustc, and thus are gated on the
-// ldk_bench flag.
-#[cfg(ldk_bench)]
-const _NODE_MAP_SIZE_TWO_CACHE_LINES: usize = 128 - core::mem::size_of::<(NodeId, PathBuildingHop)>();
-#[cfg(ldk_bench)]
-const _NODE_MAP_SIZE_EXACTLY_CACHE_LINES: usize = core::mem::size_of::<(NodeId, PathBuildingHop)>() - 128;
+const _NODE_MAP_SIZE_TWO_CACHE_LINES: usize = 128 - core::mem::size_of::<Option<PathBuildingHop>>();
+const _NODE_MAP_SIZE_EXACTLY_TWO_CACHE_LINES: usize = core::mem::size_of::<Option<PathBuildingHop>>() - 128;
 
 impl<'a> core::fmt::Debug for PathBuildingHop<'a> {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> Result<(), core::fmt::Error> {
@@ -2039,14 +2020,15 @@ where L::Target: Logger {
                                                // Can't overflow due to how the values were computed right above.
                                                None => unreachable!(),
                                        };
+                                       let htlc_minimum_msat = $candidate.htlc_minimum_msat();
                                        #[allow(unused_comparisons)] // $next_hops_path_htlc_minimum_msat is 0 in some calls so rustc complains
-                                       let over_path_minimum_msat = amount_to_transfer_over_msat >= $candidate.htlc_minimum_msat() &&
+                                       let over_path_minimum_msat = amount_to_transfer_over_msat >= htlc_minimum_msat &&
                                                amount_to_transfer_over_msat >= $next_hops_path_htlc_minimum_msat;
 
                                        #[allow(unused_comparisons)] // $next_hops_path_htlc_minimum_msat is 0 in some calls so rustc complains
                                        let may_overpay_to_meet_path_minimum_msat =
-                                               ((amount_to_transfer_over_msat < $candidate.htlc_minimum_msat() &&
-                                                 recommended_value_msat >= $candidate.htlc_minimum_msat()) ||
+                                               ((amount_to_transfer_over_msat < htlc_minimum_msat &&
+                                                 recommended_value_msat >= htlc_minimum_msat) ||
                                                 (amount_to_transfer_over_msat < $next_hops_path_htlc_minimum_msat &&
                                                  recommended_value_msat >= $next_hops_path_htlc_minimum_msat));