askrene: add maxparts

Changelog-Added: askrene: add a new parameter maxparts to getroutes that limits the number of routes in the solution.

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

Author: Lagrang3

doc/schemas/getroutes.json

@@ -73,6 +73,14 @@
           "Maximum number of blocks of delay for the route. Cannot be bigger than 2016."
         ],
         "default": "2016"
+      },
+      "maxparts": {
+        "type": "u32",
+        "added": "v25.09",
+        "description": [
+          "Maximum number of routes in the solution."
+        ],
+        "default": "6"
       }
     }
   },

plugins/askrene/askrene.c

@@ -366,6 +366,7 @@ struct getroutes_info {
 	struct additional_cost_htable *additional_costs;
 	/* Non-NULL if we are told to use "auto.localchans" */
 	struct layer *local_layer;
+	u32 maxparts;
 };
 
 static void apply_layers(struct askrene *askrene, struct route_query *rq,
@@ -551,6 +552,7 @@ static struct command_result *do_getroutes(struct command *cmd,
 	rq->capacities = tal_dup_talarr(rq, fp16_t, askrene->capacities);
 	/* FIXME: we still need to do something useful with these */
 	rq->additional_costs = info->additional_costs;
+	rq->maxparts = info->maxparts;
 
 	/* apply selected layers to the localmods */
 	apply_layers(askrene, rq, &info->source, info->amount, localmods,
@@ -764,12 +766,14 @@ static struct command_result *json_getroutes(struct command *cmd,
 	 */
 	/* FIXME: Typo in spec for CLTV in descripton! But it breaks our spelling check, so we omit it above */
 	const u32 maxdelay_allowed = 2016;
+	const u32 default_maxparts = 6;
 	struct getroutes_info *info = tal(cmd, struct getroutes_info);
 	/* param functions require pointers */
 	struct node_id *source, *dest;
 	struct amount_msat *amount, *maxfee;
 	u32 *finalcltv, *maxdelay;
 	enum algorithm *dev_algo;
+	u32 *maxparts;
 
 	if (!param_check(cmd, buffer, params,
 			 p_req("source", param_node_id, &source),
@@ -780,6 +784,8 @@ static struct command_result *json_getroutes(struct command *cmd,
 			 p_req("final_cltv", param_u32, &finalcltv),
 			 p_opt_def("maxdelay", param_u32, &maxdelay,
 				   maxdelay_allowed),
+			 p_opt_def("maxparts", param_u32, &maxparts,
+				   default_maxparts),
 			 p_opt_dev("dev_algorithm", param_algorithm,
 				   &dev_algo, ALGO_DEFAULT),
 			 NULL))
@@ -811,6 +817,7 @@ static struct command_result *json_getroutes(struct command *cmd,
 	info->dev_algo = *dev_algo;
 	info->additional_costs = tal(info, struct additional_cost_htable);
 	additional_cost_htable_init(info->additional_costs);
+	info->maxparts = *maxparts;
 
 	if (have_layer(info->layers, "auto.localchans")) {
 		struct out_req *req;

plugins/askrene/askrene.h

@@ -64,6 +64,9 @@ struct route_query {
 
 	/* channels we disable during computation to meet constraints */
 	bitmap *disabled_chans;
+
+	/* limit the number of paths in the solution */
+	u32 maxparts;
 };
 
 /* Given a gossmap channel, get the current known min/max */

plugins/askrene/mcf.c

@@ -1375,7 +1375,27 @@ linear_routes(const tal_t *ctx, struct route_query *rq,
 	struct reserve_hop *reservations = new_reservations(working_ctx, rq);
 
 	while (!amount_msat_is_zero(amount_to_deliver)) {
-                new_flows = tal_free(new_flows);
+		u32 num_parts, parts_slots, excess_parts;
+
+                /* FIXME: This algorithm to limit the number of parts is dumb
+                 * for two reasons:
+                 *      1. it does not take into account that several loop
+                 *      iterations here may produce two flows along the same
+                 *      path that after "squash_flows" become a single flow.
+                 *      2. limiting the number of "slots" to 1 makes us fail to
+                 *      see some solutions that use more than one of those
+                 *      existing paths.
+                 *
+                 * A better approach could be to run MCF, remove the excess
+                 * paths and then recompute a MCF on a network where each arc is
+                 * one of the previously remaining paths, ie. redistributing the
+                 * payment amount among the selected paths in a cost-efficient
+                 * way. */
+		new_flows = tal_free(new_flows);
+		num_parts = tal_count(*flows);
+		assert(num_parts < rq->maxparts);
+		parts_slots = rq->maxparts - num_parts;
+		excess_parts = 0;
 
 		/* If the amount_to_deliver is very small we better use a single
 		 * path computation because:
@@ -1385,9 +1405,12 @@ linear_routes(const tal_t *ctx, struct route_query *rq,
                  * refine_with_fees_and_limits we might have a set of flows that
                  * do not deliver the entire payment amount by just a small
                  * amount. */
-		if(amount_msat_less_eq(amount_to_deliver, SINGLE_PATH_THRESHOLD)){
-                        new_flows = single_path_flow(working_ctx, rq, srcnode, dstnode,
-                                amount_to_deliver, mu, delay_feefactor);
+		if (amount_msat_less_eq(amount_to_deliver,
+					SINGLE_PATH_THRESHOLD) ||
+		    parts_slots == 1) {
+			new_flows = single_path_flow(working_ctx, rq, srcnode,
+						     dstnode, amount_to_deliver,
+						     mu, delay_feefactor);
 		} else {
 			new_flows =
 			    solver(working_ctx, rq, srcnode, dstnode,
@@ -1425,6 +1448,26 @@ linear_routes(const tal_t *ctx, struct route_query *rq,
 			assert(!amount_msat_is_zero(new_flows[i]->delivers));
 		}
 
+		if (tal_count(new_flows) > parts_slots) {
+			/* Remove the excees of parts and leave one slot for the
+			 * next round of computations. */
+			excess_parts = 1 + tal_count(new_flows) - parts_slots;
+		} else if (tal_count(new_flows) == parts_slots &&
+			   amount_msat_less(all_deliver, amount_to_deliver)) {
+			/* Leave exactly 1 slot for the next round of
+			 * computations. */
+			excess_parts = 1;
+		}
+		if (excess_parts > 0 &&
+		    !remove_flows(ctx, &new_flows, excess_parts)) {
+			error_message = rq_log(ctx, rq, LOG_BROKEN,
+					       "%s: failed to remove %" PRIu32
+					       " flows from a set of %zu",
+					       __func__, excess_parts,
+					       tal_count(new_flows));
+			goto fail;
+		}
+
 		/* Is this set of flows too expensive?
 		 * We can check if the new flows are within the fee budget,
 		 * however in some cases we have discarded some flows at this
@@ -1570,6 +1613,16 @@ linear_routes(const tal_t *ctx, struct route_query *rq,
 		*flows = tal_free(*flows);
 		goto fail;
 	}
+	if (tal_count(*flows) > rq->maxparts) {
+		error_message = rq_log(
+		    rq, rq, LOG_BROKEN,
+		    "%s: the number of flows (%zu) exceeds the limit set "
+		    "on payment parts (%" PRIu32
+		    "), please submit a bug report",
+		    __func__, tal_count(*flows), rq->maxparts);
+		*flows = tal_free(*flows);
+		goto fail;
+	}
 
 	return NULL;
 fail: