lightning/common/dijkstra.c

/* Without this, gheap is *really* slow!  Comment out for debugging. */
#define NDEBUG
#include <ccan/cast/cast.h>
#include <ccan/err/err.h>
#include <ccan/tal/str/str.h>
#include <ccan/time/time.h>
#include <common/dijkstra.h>
#include <common/gossmap.h>
#include <gheap.h>
#include <inttypes.h>
#include <stdio.h>

/* Each node has this side-info. */
struct dijkstra {
	u32 distance;
	/* Total CLTV delay */
	u32 total_delay;
	/* Total cost from here to destination */
	struct amount_msat cost;
	/* I want to use an index here, except that gheap moves things onto
	 * a temporary on the stack and that makes things complex. */
	/* NULL means it's been visited already. */
	const struct gossmap_node **heapptr;

	/* We could re-evaluate to determine this, but keeps it simple */
	struct gossmap_chan *best_chan;
};

/* Because item_mover doesn't provide a ctx ptr, we need a global anyway. */
static struct dijkstra *global_dijkstra;
static const struct gossmap *global_map;

/* Returns UINT_MAX if unreachable. */
u32 dijkstra_distance(const struct dijkstra *dij, u32 node_idx)
{
	return dij[node_idx].distance;
}

/* Total CLTV delay */
u32 dijkstra_delay(const struct dijkstra *dij, u32 node_idx)
{
	return dij[node_idx].total_delay;
}

/* Total cost to get here. */
struct amount_msat dijkstra_amount(const struct dijkstra *dij, u32 node_idx)
{
	return dij[node_idx].cost;
}

struct gossmap_chan *dijkstra_best_chan(const struct dijkstra *dij,
					u32 node_idx)
{
	return dij[node_idx].best_chan;
}

static struct dijkstra *get_dijkstra(const struct dijkstra *dij,
				     const struct gossmap *map,
				     const struct gossmap_node *n)
{
	return cast_const(struct dijkstra *, dij) + gossmap_node_idx(map, n);
}

/* We want a minheap, not a maxheap, so this is backwards! */
static int less_comparer(const void *const ctx,
			 const void *const a,
			 const void *const b)
{
	return get_dijkstra(global_dijkstra, global_map,
			    *(struct gossmap_node **)a)->distance
		> get_dijkstra(global_dijkstra, global_map,
			       *(struct gossmap_node **)b)->distance;
}

static void item_mover(void *const dst, const void *const src)
{
	struct gossmap_node *n = *((struct gossmap_node **)src);
	get_dijkstra(global_dijkstra, global_map, n)->heapptr = dst;
	*((struct gossmap_node **)dst) = n;
}

static const struct gossmap_node **mkheap(const tal_t *ctx,
					  struct dijkstra *dij,
					  const struct gossmap *map,
					  const struct gossmap_node *start,
					  struct amount_msat sent)
{
	const struct gossmap_node *n, **heap;
	size_t i;

	heap = tal_arr(tmpctx, const struct gossmap_node *,
		       gossmap_num_nodes(map));
	for (i = 1, n = gossmap_first_node(map);
	     n;
	     n = gossmap_next_node(map, n), i++) {
		struct dijkstra *d = get_dijkstra(dij, map, n);
		if (n == start) {
			/* First entry in heap is start, distance 0 */
			heap[0] = start;
			d->heapptr = &heap[0];
			d->distance = 0;
			d->total_delay = 0;
			d->cost = sent;
			i--;
		} else {
			heap[i] = n;
			d->heapptr = &heap[i];
			d->distance = UINT_MAX;
			d->cost = AMOUNT_MSAT(-1ULL);
			d->total_delay = 0;
		}
	}
	assert(i == tal_count(heap));
	return heap;
}

/* 365.25 * 24 * 60 / 10 */
#define BLOCKS_PER_YEAR 52596

/* We price in risk as riskfactor percent per year. */
static struct amount_msat risk_price(struct amount_msat amount,
				     u32 riskfactor, u32 cltv_delay)
{
	struct amount_msat riskfee;

	if (!amount_msat_scale(&riskfee, amount,
			       riskfactor / 100.0 / BLOCKS_PER_YEAR
			       * cltv_delay))
		return AMOUNT_MSAT(-1ULL);
	return riskfee;
}

/* Do Dijkstra: start in this case is the dst node. */
const struct dijkstra *
dijkstra_(const tal_t *ctx,
	  const struct gossmap *map,
	  const struct gossmap_node *start,
	  struct amount_msat amount,
	  double riskfactor,
	  bool (*channel_ok)(const struct gossmap *map,
			     const struct gossmap_chan *c,
			     int dir,
			     struct amount_msat amount,
			     void *arg),
	  bool (*path_better)(u32 old_distance,
			      u32 new_distance,
			      struct amount_msat old_cost,
			      struct amount_msat new_cost,
			      struct amount_msat old_risk,
			      struct amount_msat new_risk,
			      void *arg),
	  void *arg)
{
	struct dijkstra *dij;
	const struct gossmap_node **heap;
	size_t heapsize;
	struct gheap_ctx gheap_ctx;

	/* There doesn't seem to be much difference with fanout 2-4. */
	gheap_ctx.fanout = 2;
	/* There seems to be a slight decrease if we alter this value. */
	gheap_ctx.page_chunks = 1;
	gheap_ctx.item_size = sizeof(*heap);
	gheap_ctx.less_comparer = less_comparer;
	gheap_ctx.less_comparer_ctx = NULL;
	gheap_ctx.item_mover = item_mover;

	dij = tal_arr(ctx, struct dijkstra, gossmap_max_node_idx(map));

	/* Pay no attention to the man behind the curtain! */
	global_map = map;
	global_dijkstra = dij;

	/* Wikipedia's article on Dijkstra is excellent:
	 *    https://en.wikipedia.org/wiki/Dijkstra's_algorithm
	 * (License https://creativecommons.org/licenses/by-sa/3.0/)
	 *
	 * So I quote here:
	 *
	 * 1. Mark all nodes unvisited. Create a set of all the unvisited
	 * nodes called the unvisited set.
	 *
	 * 2. Assign to every node a tentative distance value: set it to zero
	 * for our initial node and to infinity for all other nodes. Set the
	 * initial node as current.[14]
	 */
	heap = mkheap(NULL, dij, map, start, amount);
	heapsize = tal_count(heap);

	/*
	 * 3. For the current node, consider all of its unvisited neighbouds
	 * and calculate their tentative distances through the current
	 * node. Compare the newly calculated tentative distance to the
	 * current assigned value and assign the smaller one. For example, if
	 * the current node A is marked with a distance of 6, and the edge
	 * connecting it with a neighbour B has length 2, then the distance to
	 * B through A will be 6 + 2 = 8. If B was previously marked with a
	 * distance greater than 8 then change it to 8. Otherwise, the current
	 * value will be kept.
	 *
	 * 4. When we are done considering all of the unvisited neighbouds of
	 * the current node, mark the current node as visited and remove it
	 * from the unvisited set. A visited node will never be checked again.
	 *
	 * 5. If the destination node has been marked visited (when planning a
	 * route between two specific nodes) or if the smallest tentative
	 * distance among the nodes in the unvisited set is infinity (when
	 * planning a complete travedsal; occuds when there is no connection
	 * between the initial node and remaining unvisited nodes), then
	 * stop. The algorithm has finished.
	 *
	 * 6.  Otherwise, select the unvisited node that is marked with the
	 * smallest tentative distance, set it as the new "current node", and
	 * go back to step 3.
	 */
	while (heapsize != 0) {
		struct dijkstra *cur_d;
		const struct gossmap_node *cur = heap[0];

		cur_d = get_dijkstra(dij, map, cur);
		assert(cur_d->heapptr == heap);

		/* Finished all reachable nodes */
		if (cur_d->distance == UINT_MAX)
			break;

		for (size_t i = 0; i < cur->num_chans; i++) {
			struct gossmap_node *neighbor;
			int which_half;
			struct gossmap_chan *c;
			struct dijkstra *d;
			struct amount_msat cost, new_risk, old_risk;

			c = gossmap_nth_chan(map, cur, i, &which_half);
			neighbor = gossmap_nth_node(map, c, !which_half);

			d = get_dijkstra(dij, map, neighbor);
			/* Ignore if already visited. */
			if (!d->heapptr)
				continue;

			/* We're going from neighbor to c, hence !which_half */
			if (!channel_ok(map, c, !which_half, cur_d->cost, arg))
				continue;

			cost = cur_d->cost;
			if (!amount_msat_add_fee(&cost,
						 c->half[!which_half].base_fee,
						 c->half[!which_half].proportional_fee))
				/* Shouldn't happen! */
				continue;

			/* cltv_delay can't overflow: only 20 bits per hop. */
			new_risk = risk_price(cost, riskfactor,
					      cur_d->total_delay
					      + c->half[!which_half].delay);

			old_risk = risk_price(d->cost, riskfactor,
					      d->total_delay);

			if (!path_better(d->distance,
					 cur_d->distance + 1,
					 d->cost,
					 cost,
					 old_risk,
					 new_risk,
					 arg))
				continue;

			d->distance = cur_d->distance + 1;
			d->total_delay = cur_d->total_delay
				+ c->half[!which_half].delay;
			d->cost = cost;
			d->best_chan = c;
			gheap_restore_heap_after_item_increase(&gheap_ctx,
							       heap, heapsize,
							       d->heapptr - heap);
		}
		gheap_pop_heap(&gheap_ctx, heap, heapsize--);
		cur_d->heapptr = NULL;
	}
	tal_free(heap);
	return dij;
}