askrene: optimize, by calling tal_count less.

I like the clarity, but this is a hot path.  Fortunately these arrays
have very well defined lengths.

Before: 5.81 seconds
After: 1.06 seconds

Signed-off-by: Rusty Russell <[email protected]>

Author: rustyrussell

plugins/askrene/mcf.c

@@ -392,7 +392,7 @@ static s64 get_arc_flow(
 static u32 arc_tail(const struct linear_network *linear_network,
                     const struct arc arc)
 {
-	assert(arc.idx < tal_count(linear_network->arc_tail_node));
+	assert(arc.idx < linear_network->max_num_arcs);
 	return linear_network->arc_tail_node[ arc.idx ];
 }
 /* Helper function.
@@ -401,7 +401,7 @@ static u32 arc_head(const struct linear_network *linear_network,
                     const struct arc arc)
 {
 	const struct arc dual = arc_dual(arc);
-	assert(dual.idx < tal_count(linear_network->arc_tail_node));
+	assert(dual.idx < linear_network->max_num_arcs);
 	return linear_network->arc_tail_node[dual.idx];
 }
 
@@ -412,7 +412,7 @@ static struct arc node_adjacency_begin(
 		const struct linear_network * linear_network,
 		const u32 node)
 {
-	assert(node < tal_count(linear_network->node_adjacency_first_arc));
+	assert(node < linear_network->max_num_nodes);
 	return linear_network->node_adjacency_first_arc[node];
 }
 
@@ -429,7 +429,7 @@ static struct arc node_adjacency_next(
 		const struct linear_network *linear_network,
 		const struct arc arc)
 {
-	assert(arc.idx < tal_count(linear_network->node_adjacency_next_arc));
+	assert(arc.idx < linear_network->max_num_arcs);
 	return linear_network->node_adjacency_next_arc[arc.idx];
 }
 
@@ -540,16 +540,13 @@ static void linear_network_add_adjacenct_arc(
 		const u32 node_idx,
 		const struct arc arc)
 {
-	assert(arc.idx < tal_count(linear_network->arc_tail_node));
+	assert(arc.idx < linear_network->max_num_arcs);
 	linear_network->arc_tail_node[arc.idx] = node_idx;
 
-	assert(node_idx < tal_count(linear_network->node_adjacency_first_arc));
+	assert(node_idx < linear_network->max_num_nodes);
 	const struct arc first_arc = linear_network->node_adjacency_first_arc[node_idx];
 
-	assert(arc.idx < tal_count(linear_network->node_adjacency_next_arc));
 	linear_network->node_adjacency_next_arc[arc.idx]=first_arc;
-
-	assert(node_idx < tal_count(linear_network->node_adjacency_first_arc));
 	linear_network->node_adjacency_first_arc[node_idx]=arc;
 }
 
@@ -596,23 +593,23 @@ init_linear_network(const tal_t *ctx, const struct pay_parameters *params)
 	linear_network->max_num_nodes = max_num_nodes;
 
 	linear_network->arc_tail_node = tal_arr(linear_network,u32,max_num_arcs);
-	for(size_t i=0;i<tal_count(linear_network->arc_tail_node);++i)
+	for(size_t i=0;i<max_num_arcs;++i)
 		linear_network->arc_tail_node[i]=INVALID_INDEX;
 
 	linear_network->node_adjacency_next_arc = tal_arr(linear_network,struct arc,max_num_arcs);
-	for(size_t i=0;i<tal_count(linear_network->node_adjacency_next_arc);++i)
+	for(size_t i=0;i<max_num_arcs;++i)
 		linear_network->node_adjacency_next_arc[i].idx=INVALID_INDEX;
 
 	linear_network->node_adjacency_first_arc = tal_arr(linear_network,struct arc,max_num_nodes);
-	for(size_t i=0;i<tal_count(linear_network->node_adjacency_first_arc);++i)
+	for(size_t i=0;i<max_num_nodes;++i)
 		linear_network->node_adjacency_first_arc[i].idx=INVALID_INDEX;
 
 	linear_network->arc_prob_cost = tal_arr(linear_network,s64,max_num_arcs);
-	for(size_t i=0;i<tal_count(linear_network->arc_prob_cost);++i)
+	for(size_t i=0;i<max_num_arcs;++i)
 		linear_network->arc_prob_cost[i]=INFINITE;
 
 	linear_network->arc_fee_cost = tal_arr(linear_network,s64,max_num_arcs);
-	for(size_t i=0;i<tal_count(linear_network->arc_fee_cost);++i)
+	for(size_t i=0;i<max_num_arcs;++i)
 		linear_network->arc_fee_cost[i]=INFINITE;
 
 	linear_network->capacity = tal_arrz(linear_network,s64,max_num_arcs);
@@ -699,9 +696,9 @@ find_admissible_path(const struct linear_network *linear_network,
 	bool target_found = false;
 	/* Simple linear queue of node indexes */
 	u32 *queue = tal_arr(tmpctx, u32, linear_network->max_num_arcs);
-	size_t qstart, qend;
+	size_t qstart, qend, prev_len = tal_count(prev);
 
-	for(size_t i=0;i<tal_count(prev);++i)
+	for(size_t i=0;i<prev_len;++i)
 		prev[i].idx=INVALID_INDEX;
 
 	// The graph is dense, and the farthest node is just a few hops away,
@@ -729,7 +726,7 @@ find_admissible_path(const struct linear_network *linear_network,
 
 			u32 next = arc_head(linear_network,arc);
 
-			assert(next < tal_count(prev));
+			assert(next < prev_len);
 
 			// if that node has been seen previously
 			if(prev[next].idx!=INVALID_INDEX)