askrene: refactor disabled channels/nodes

Use a bitmap to mark disabled channels instead of tweaking values in
localmods.

Signed-off-by: Lagrang3 <[email protected]>

Author: Lagrang3

plugins/askrene/askrene.c

@@ -337,6 +337,12 @@ static const char *get_routes(const tal_t *ctx,
 
 	gossmap_apply_localmods(askrene->gossmap, localmods);
 
+	rq->disabled = tal_get_disabled_bitmap(rq, rq);
+	if (!rq->disabled) {
+		ret = tal_fmt(ctx, "Failed creation of disabled bitmap.");
+		goto out;
+	}
+
 	srcnode = gossmap_find_node(askrene->gossmap, source);
 	if (!srcnode) {
 		ret = tal_fmt(ctx, "Unknown source node %s", fmt_node_id(tmpctx, source));

plugins/askrene/askrene.h

@@ -2,6 +2,7 @@
 #define LIGHTNING_PLUGINS_ASKRENE_ASKRENE_H
 #include "config.h"
 #include <bitcoin/short_channel_id.h>
+#include <ccan/bitmap/bitmap.h>
 #include <ccan/htable/htable_type.h>
 #include <ccan/list/list.h>
 #include <common/amount.h>
@@ -41,6 +42,10 @@ struct route_query {
 	/* This is *not* updated during a query!  Has all layers applied. */
 	const struct gossmap *gossmap;
 
+	/* Bit is set for [idx*2+dir] if that channel is disabled or if it
+	 * belongs to a disabled node.. */
+	bitmap *disabled;
+
 	/* We need to take in-flight payments into account */
 	const struct reserve_htable *reserved;
 

plugins/askrene/layer.c

@@ -323,37 +323,6 @@ void layer_add_localmods(const struct layer *layer,
 	const struct local_channel *lc;
 	struct local_channel_hash_iter lcit;
 
-	/* First, disable all channels into blocked nodes (local updates
-	 * can add new ones)! */
-	for (size_t i = 0; i < tal_count(layer->disabled); i++) {
-		struct route_exclusion ex = layer->disabled[i];
-
-		/* Disable all channels of excluded nodes. */
-		if (ex.type == EXCLUDE_NODE) {
-			const struct gossmap_node *node;
-
-			node = gossmap_find_node(gossmap, &ex.u.node_id);
-			if (!node)
-				continue;
-			for (size_t n = 0; n < node->num_chans; n++) {
-				struct short_channel_id scid;
-				struct gossmap_chan *c;
-				int dir;
-				c = gossmap_nth_chan(gossmap, node, n, &dir);
-				scid = gossmap_chan_scid(gossmap, c);
-
-				/* Disabled zero-capacity on incoming */
-				gossmap_local_updatechan(
-				    localmods, scid, AMOUNT_MSAT(0),
-				    AMOUNT_MSAT(0), 0, 0, 0, false, !dir);
-			}
-		} else {
-			gossmap_local_updatechan(
-			    localmods, ex.u.chan_id.scid, AMOUNT_MSAT(0),
-			    AMOUNT_MSAT(0), 0, 0, 0, false, ex.u.chan_id.dir);
-		}
-	}
-
 	for (lc = local_channel_hash_first(layer->local_channels, &lcit);
 	     lc;
 	     lc = local_channel_hash_next(layer->local_channels, &lcit)) {
@@ -489,3 +458,56 @@ void layer_memleak_mark(struct askrene *askrene, struct htable *memtable)
 		memleak_scan_htable(memtable, &l->local_channels->raw);
 	}
 }
+
+static void set_channel_bit(bitmap *bm, const struct gossmap *gossmap,
+			    const struct short_channel_id_dir *scidd)
+{
+	const struct gossmap_chan *chan =
+	    gossmap_find_chan(gossmap, &scidd->scid);
+
+	if (!chan)
+		return;
+
+	bitmap_set_bit(bm, gossmap_chan_idx(gossmap, chan) * 2 + scidd->dir);
+}
+
+static void set_node_channels_bit(bitmap *bm, const struct gossmap *gossmap,
+				  const struct node_id *node_id)
+{
+	const struct gossmap_node *node = gossmap_find_node(gossmap, node_id);
+	for (size_t k = 0; k < node->num_chans; k++) {
+		int half;
+		const struct gossmap_chan *chan =
+		    gossmap_nth_chan(gossmap, node, k, &half);
+
+		bitmap_set_bit(bm, gossmap_chan_idx(gossmap, chan) * 2 + half);
+		bitmap_set_bit(bm, gossmap_chan_idx(gossmap, chan) * 2 + !half);
+	}
+}
+
+bitmap *tal_get_disabled_bitmap(const tal_t *ctx, struct route_query *rq)
+{
+
+	bitmap *disabled = tal_arrz(
+	    ctx, bitmap, 2 * BITMAP_NWORDS(gossmap_max_chan_idx(rq->gossmap)));
+
+	if (!disabled)
+		return NULL;
+
+	/* Disable every channel in the list of disabled scids. */
+	for (size_t i = 0; i < tal_count(rq->layers); i++) {
+		const struct layer *l = rq->layers[i];
+
+		for (size_t j = 0; j < tal_count(l->disabled); j++) {
+			const struct route_exclusion *ex = &l->disabled[j];
+
+			if (ex->type == EXCLUDE_CHANNEL)
+				set_channel_bit(disabled, rq->gossmap,
+						&ex->u.chan_id);
+			else
+				set_node_channels_bit(disabled, rq->gossmap,
+						      &ex->u.node_id);
+		}
+	}
+	return disabled;
+}

plugins/askrene/layer.h

@@ -120,4 +120,9 @@ void json_add_constraint(struct json_stream *js,
 
 /* Scan for memleaks */
 void layer_memleak_mark(struct askrene *askrene, struct htable *memtable);
+
+/* Creates a bitmap of disabled channels. It loops over all layers in the
+ * query searching for disabled channels and disabled nodes. All channels
+ * linked to a disabled node will be disabled. */
+bitmap *tal_get_disabled_bitmap(const tal_t *ctx, struct route_query *rq);
 #endif /* LIGHTNING_PLUGINS_ASKRENE_LAYER_H */

plugins/askrene/mcf.c

@@ -583,11 +583,22 @@ static s64 linear_fee_cost(
 	return pfee + bfee* base_fee_penalty+ delay*delay_feefactor;
 }
 
+static bool channel_is_available(const struct gossmap_chan *c, int dir,
+				 const struct gossmap *gossmap,
+				 const bitmap *disabled)
+{
+	if (!gossmap_chan_set(c, dir))
+		return false;
+	const u32 chan_idx = gossmap_chan_idx(gossmap, c);
+	return !bitmap_test_bit(disabled, chan_idx * 2 + dir);
+}
+
 static struct linear_network *
 init_linear_network(const tal_t *ctx, const struct pay_parameters *params)
 {
 	struct linear_network * linear_network = tal(ctx, struct linear_network);
 	const struct gossmap *gossmap = params->rq->gossmap;
+	const bitmap *disabled = params->rq->disabled;
 
 	const size_t max_num_chans = gossmap_max_chan_idx(gossmap);
 	const size_t max_num_arcs = max_num_chans * ARCS_PER_CHANNEL;
@@ -630,7 +641,7 @@ init_linear_network(const tal_t *ctx, const struct pay_parameters *params)
 			const struct gossmap_chan *c = gossmap_nth_chan(gossmap,
 			                                                node, j, &half);
 
-			if (!gossmap_chan_set(c, half))
+			if (!channel_is_available(c, half, gossmap, disabled))
 				continue;
 
 			const u32 chan_id = gossmap_chan_idx(gossmap, c);

tests/test_askrene.py

@@ -172,6 +172,8 @@ def test_getroutes(node_factory):
     l1.rpc.askrene_disable_channel("chans_disabled", "0x1x0")
     l1.rpc.askrene_disable_channel("chans_disabled", "0x2x1")
     l1.rpc.askrene_disable_channel("chans_disabled", "0x2x3")
+    # we can also disable by mistake channels that do not exists
+    l1.rpc.askrene_disable_channel("chans_disabled", "111x222x333")
     with pytest.raises(RpcError, match="Could not find route"):
         l1.rpc.getroutes(source=nodemap[0],
                          destination=nodemap[1],