askrene: fix bug, not all arcs exists

We use an arc "array" in the graph structure, but not all arc indexes
correspond to real topological arcs. We must be careful when iterating
through all arcs, and check if they are enabled before making operations
on them.

Changelog-None: askrene: fix bug, not all arcs exists

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

Author: Lagrang3

plugins/askrene/algorithm.c

@@ -554,8 +554,9 @@ static bool mcf_refinement(const tal_t *ctx,
 	 * constraints.  */
 	for (u32 arc_id = 0; arc_id < max_num_arcs; arc_id++) {
 		struct arc arc = {.idx = arc_id};
+		if(!arc_enabled(graph, arc))
+			continue;
 		const s64 r = capacity[arc.idx];
-
 		if (reduced_cost(graph, arc, cost, potential) < 0 && r > 0) {
 			/* This arc's reduced cost is negative and non
 			 * saturated. */
@@ -615,7 +616,19 @@ static bool mcf_refinement(const tal_t *ctx,
 	for (u32 i = 0; i < max_num_nodes; i++) {
 		assert(excess[i] == 0);
 	}
+	for (u32 i = 0; i < max_num_arcs; i++) {
+		struct arc arc = {.idx = i};
+		if(!arc_enabled(graph, arc))
+			continue;
+		const s64 cap = capacity[arc.idx];
+		const s64 rc = reduced_cost(graph, arc, cost, potential);
+
+		assert(cap >= 0);
+		/* asserts logic implication: (rc<0 -> cap==0)*/
+		assert(!(rc < 0) || cap == 0);
+	}
 #endif
+	solved = true;
 
 finish:
 	tal_free(this_ctx);

plugins/askrene/graph.h

@@ -97,6 +97,12 @@ static inline struct node arc_head(const struct graph *graph,
 	return graph->arc_tail[dual.idx];
 }
 
+/* We use an arc array but not all arcs in that array do exist in the graph. */
+static inline bool arc_enabled(const struct graph *graph, const struct arc arc)
+{
+	return graph->arc_tail[arc.idx].idx < graph->max_num_nodes;
+}
+
 /* Used to loop over the arcs that exit a node.
  *
  * for example:

plugins/askrene/test/run-mcf-large.c

@@ -22,6 +22,10 @@
  * A feasible solution is guaranteed.
  * The last test case has 0 nodes and should be ignored. */
 
+/* check-source does not like me to use scanf, how am I going to read the test
+ * data otherwise? */
+#define myscanf scanf
+
 static int next_bit(s64 x)
 {
 	int b;
@@ -37,7 +41,7 @@ static bool solve_case(const tal_t *ctx)
 	tal_t *this_ctx = tal(ctx, tal_t);
 
 	int N_nodes, N_arcs;
-	scanf("%d %d\n", &N_nodes, &N_arcs);
+	myscanf("%d %d\n", &N_nodes, &N_arcs);
 	printf("Testcase %d\n", c);
 	printf("nodes %d arcs %d\n", N_nodes, N_arcs);
 	if (N_nodes == 0 && N_arcs == 0)
@@ -49,14 +53,14 @@ static bool solve_case(const tal_t *ctx)
 	printf("max nodes %d max arcs %d bit %d\n", MAX_NODES, MAX_ARCS, DUAL_BIT);
 
 	struct graph *graph = graph_new(ctx, MAX_NODES, MAX_ARCS, DUAL_BIT);
-	assert(graph);
+	CHECK(graph);
 
 	s64 *capacity = tal_arrz(ctx, s64, MAX_ARCS);
 	s64 *cost = tal_arrz(ctx, s64, MAX_ARCS);
 
 	for (u32 i = 0; i < N_arcs; i++) {
 		u32 from, to;
-		scanf("%" PRIu32 " %" PRIu32 " %" PRIi64 " %" PRIi64, &from,
+		myscanf("%" PRIu32 " %" PRIu32 " %" PRIi64 " %" PRIi64, &from,
 		      &to, &capacity[i], &cost[i]);
 
 		struct arc arc = {.idx = i};
@@ -70,19 +74,19 @@ static bool solve_case(const tal_t *ctx)
 	struct node dst = {.idx = 1};
 
 	s64 amount, best_cost;
-	scanf("%" PRIi64 " %" PRIi64, &amount, &best_cost);
+	myscanf("%" PRIi64 " %" PRIi64, &amount, &best_cost);
 
 	bool result = simple_mcf(ctx, graph, src, dst, capacity, amount, cost);
-	assert(result);
+	CHECK(result);
 
-	assert(node_balance(graph, src, capacity) == -amount);
-	assert(node_balance(graph, dst, capacity) == amount);
+	CHECK(node_balance(graph, src, capacity) == -amount);
+	CHECK(node_balance(graph, dst, capacity) == amount);
 
 	for (u32 i = 2; i < N_nodes; i++)
-		assert(node_balance(graph, node_obj(i), capacity) == 0);
+		CHECK(node_balance(graph, node_obj(i), capacity) == 0);
 
 	const s64 total_cost = flow_cost(graph, capacity, cost);
-	assert(total_cost == best_cost);
+	CHECK(total_cost == best_cost);
 
 	tal_free(this_ctx);
 	return true;
@@ -97,7 +101,7 @@ int main(int argc, char *argv[])
 	common_setup(argv[0]);
 	freopen("plugins/askrene/test/data/linear_mcf", "r", stdin);
 	tal_t *ctx = tal(NULL, tal_t);
-	assert(ctx);
+	CHECK(ctx);
 
 	/* One test case after another. The last test case has N number of nodes
 	 * and arcs equal to 0 and must be ignored. */