@davidsouther/agathon 0.0.0-stage → 2026.11.1

package/src/samples/load_generator.ts

@@ -0,0 +1,213 @@
+/**
+ * @fileoverview Generate a large graph, with some parameters to control size.
+ */
+
+import type { LayoutGraph } from "../layout/types.ts";
+import { TsabreGraph } from "../tsabre/graph.ts";
+import type { Edge, Node, NodeId } from "../types.ts";
+
+const DINO_NAMES = `Vulcanodontidae
+Tyrannosauridae
+Troodontidae
+Titanosauriformes
+Titanosauridae
+Thyreophora
+Theropoda
+Therizinosauridae
+Tetanurae
+Stegosauria
+Spinosauroidea
+Spinosauridae
+Somphospondyli
+Scelidosauridae
+Sauropodomorpha
+Sauropoda
+Psittacosauridae
+Protoceratopsidae
+Plateosauridae
+Pisanosauridae
+Pachycephalosauria
+Ornithopoda
+Ornithomimidae
+Ornithischia
+Omeisauridae
+Nodosauridae
+Noasauridae
+Neovenatoridae
+Neosauropoda
+Neoceratosauria
+Metriacanthosauridae
+Megalosauridae
+Megalosauria
+Massospondylidae
+Maniraptoriformes
+Maniraptora
+Macronaria
+Iojasaurus
+Iguanodontidae
+Hypsilophodontidae
+Heterodontosauridae
+Herrerasauria
+Hecodontosaurus
+Hadrosauridae
+Fabrosauridae
+Euhelopodidae
+Dromaeosauridae
+Diplodocidae
+Deinonychosauria
+Coelurosauria
+Coeluridae
+Coelophysoidea
+Cetiosauridae
+Ceratosauridae
+Ceratosauria
+Ceratopsidae
+Ceratopsia
+Cerapoda
+Carnosauria
+Carcharodontosauridae
+Camarasauridae
+Brachiosauridae
+Aves
+Ankylosauridae
+Ankylosauria
+Alvarezsauridae
+Allosauroidea
+Allosauridae
+Abelisauroidea
+Abelisauridae`.split("\n");
+
+const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVQXYZabcdefghijklmnopqrstuvqxyz".slice();
+
+/** Generate a very large graph that looks like an Istio mesh. */
+export function generateLoadMesh(
+  size = 20,
+  serviceCount = 1,
+  workloadCount = 2,
+  workloadConnections = 3,
+): string {
+  let services: string[] = [];
+  let workloads: string[] = [];
+  const servicesToWorkloads: string[] = [];
+  const workloadsToServices: string[] = [];
+
+  for (let i = 0; i < Math.min(size, DINO_NAMES.length); i++) {
+    const name = DINO_NAMES[i];
+
+    const newServices = [];
+    for (let j = 0; j < serviceCount; j++) {
+      newServices.push(`${name}_service_v${j}`);
+    }
+    services = services.concat(newServices);
+
+    const newWorkloads = [];
+    for (let j = 0; j < workloadCount; j++) {
+      const workload = `${name}_workload_v${j}`;
+      newWorkloads.push(workload);
+      for (const service of newServices) {
+        servicesToWorkloads.push(`${service} -> ${workload}`);
+      }
+    }
+    workloads = workloads.concat(newWorkloads);
+  }
+
+  for (const workload of workloads) {
+    for (let i = 0; i < workloadConnections; i++) {
+      const service = services[(Math.random() * services.length) | 0];
+      workloadsToServices.push(`${workload} -> ${service}`);
+    }
+  }
+
+  const graph = `digraph {
+      [timing=true;]
+  ${services.join(";\n")};
+
+  ${workloads.join(";\n")};
+
+  ${servicesToWorkloads.join(";\n")};
+
+  ${workloadsToServices.join(";\n")};
+}`;
+
+  return graph;
+}
+
+function makeAlphaId(i: number): string {
+  let id = "";
+  do {
+    const c = i % ALPHABET.length;
+    i = Math.floor(i / ALPHABET.length);
+    id = ALPHABET[c] + id;
+  } while (i >= ALPHABET.length);
+  id = ALPHABET[i] + id;
+  return id;
+}
+
+/** Generate a very large mesh with similar hulls */
+export function generateLoadGraph(
+  nodes: number,
+  depth: number,
+  children: number,
+  connections: number,
+  seed?: number,
+): LayoutGraph {
+  const g = new TsabreGraph<Node, Edge>();
+  const grandChildren: NodeId[] = [];
+
+  function makeChildren(pid: NodeId, d: number) {
+    for (let o = 0; o < children; o++) {
+      const id = `${pid}_${ALPHABET[o]}`;
+      g.setNode(id, { id });
+      g.setParent(id, pid);
+      if (d <= 0) {
+        grandChildren.push(id);
+      } else {
+        makeChildren(id, d - 1);
+      }
+    }
+  }
+
+  /** For testing, controllable prng */
+  function random() {
+    if (seed === undefined) return Math.random();
+    seed = (A * seed + C) % M;
+    return seed / M;
+  }
+
+  for (let n = 0; n < nodes; n++) {
+    // const id = DINO_NAMES[Math.random() * DINO_NAMES.length | 0];
+    const id = makeAlphaId(n);
+    g.setNode(id, { id });
+    makeChildren(id, depth - 1);
+  }
+
+  for (const source of grandChildren) {
+    for (let i = 0; i < connections; i++) {
+      let target = source;
+      while (target === source) {
+        target = grandChildren[(random() * grandChildren.length) | 0];
+      }
+      const edge = { source, target };
+      g.setEdge(edge, edge);
+    }
+  }
+
+  // Include edges for top level segments.
+  // TODO: Remove when layout handles top-level segments.
+  for (const id of g.children()) {
+    for (const segment of g.nodeSegments(id)) {
+      for (const edge of segment.edges) {
+        const source = g.ancestors(edge.source).pop()!;
+        const target = g.ancestors(edge.target).pop()!;
+        g.setEdge({ source, target }, { source, target });
+      }
+    }
+  }
+
+  return g;
+}
+
+// For prng, values from vbasic, older glibc, etc.
+const A = 1103515245;
+const C = 12345;
+const M = 2 ** 32;

package/src/samples/search_graph.ts

@@ -0,0 +1,35 @@
+/**
+ * String graph of the Cloud Topo "NetViz Graph" which is a good starting point
+ * for search tests.
+ */
+export const SEARCH_GRAPH = `digraph {
+  [printDebug = true;]
+
+  //compute/country/pol;
+  //compute/us-east1-c/instances/instance1;
+  //compute/us-east1-c/instances/instance2;
+  //compute/eu-west1-c/instances/instance3;
+  //compute/us-east1-c/instanceGroups/us-ig;
+  //compute/eu-west1-c/instanceGroups/eu-ig;
+  //compute/us-east1/subnet1;
+  //compute/eu-west1/subnet1;
+  //compute/us-east1/net1;
+  //compute/us-east1/net2;
+  //compute/eu-west1/net1;
+  //compute/regions/us-east1;
+  //compute/regions/eu-west1;
+
+  //compute/country/pol -> //compute/us-east1-c/instances/instance1;
+  //compute/eu-west1-c/instances/instance3 -> //compute/us-east1-c/instances/instance2;
+  //compute/us-east1-c/instanceGroups/us-ig -> //compute/us-east1-c/instances/instance1;
+  //compute/us-east1-c/instanceGroups/us-ig -> //compute/us-east1-c/instances/instance2;
+  //compute/us-east1/subnet1 -> //compute/us-east1-c/instanceGroups/us-ig;
+  //compute/us-east1/net1 -> //compute/us-east1/subnet1;
+  //compute/regions/us-east1 -> //compute/us-east1/net1;
+  //compute/regions/us-east1 -> //compute/us-east1/net2;
+  //compute/eu-west1-c/instanceGroups/eu-ig -> //compute/eu-west1-c/instances/instance3;
+  //compute/eu-west1/subnet1 -> //compute/eu-west1-c/instanceGroups/eu-ig;
+  //compute/eu-west1/net1 -> //compute/eu-west1/subnet1;
+  //compute/regions/eu-west1 -> //compute/eu-west1/net1;
+  //compute/regions/eu-west1 -> //compute/eu-west1-c/instanceGroups/eu-ig;
+}`;

package/src/tsabre/algo.ts

@@ -0,0 +1,126 @@
+import type { NodeId, SmartGraph } from "../types.ts";
+
+export * from "./dijkstra/dijkstra.ts";
+export * from "./dijkstra/heap.ts";
+
+/** A list of nodes in some path of a graph, be it a traversal or cycle. */
+export type Path = NodeId[];
+
+/**
+ * Break the graph into sets of all connected nodes.
+ */
+export function components(g: SmartGraph<unknown, unknown>): Set<Set<NodeId>> {
+  const components = new Set<Set<NodeId>>();
+  const visited = new Set<NodeId>();
+
+  function dfs(id: NodeId, component: Set<NodeId>) {
+    if (visited.has(id)) return;
+    visited.add(id);
+    component.add(id);
+    for (const next of g.neighbors(id)) {
+      dfs(next, component);
+    }
+  }
+
+  for (const id of g.nodes) {
+    const cmp = new Set<NodeId>();
+    dfs(id, cmp);
+    if (cmp.size > 0) components.add(cmp);
+  }
+
+  return components;
+}
+
+/** Order to conduct a DFS */
+export const Order = {
+  PRE: 0,
+  POST: 1,
+} as const;
+export type Order = (typeof Order)[keyof typeof Order];
+
+/**
+ * Return all node ids in a graph using either pre or post order search.
+ */
+export function dfs(
+  graph: SmartGraph<unknown, unknown>,
+  start: Iterable<NodeId>,
+  order: Order = Order.PRE,
+): NodeId[] {
+  const visit: NodeId[] = [];
+  const visited = new Set<NodeId>();
+  for (const id of start) {
+    doDfs(id);
+  }
+  return visit;
+
+  function doDfs(id: NodeId) {
+    if (visited.has(id)) return;
+    if (!graph.hasNode(id)) return;
+    visited.add(id);
+
+    if (order === Order.PRE) visit.push(id);
+    for (const nextId of graph.successors(id)) {
+      doDfs(nextId);
+    }
+    if (order === Order.POST) visit.push(id);
+  }
+}
+
+interface TarjanVisit {
+  onStack: boolean;
+  lowLink: number;
+  index: number;
+}
+
+/**
+ * Tarjan's algorithm to find strongly connected components.
+ */
+export function tarjan(g: SmartGraph<unknown, unknown>): Path[] {
+  let index = 0;
+  const stack: NodeId[] = [];
+  const visited = new Map<NodeId, TarjanVisit>();
+  const results: Path[] = [];
+
+  function dfs(id: NodeId) {
+    if (visited.has(id)) return;
+
+    const entry = { onStack: true, lowLink: index, index: index++ };
+    visited.set(id, entry);
+    stack.push(id);
+
+    for (const sId of g.successors(id)) {
+      if (!visited.has(sId)) {
+        dfs(sId);
+        entry.lowLink = Math.min(entry.lowLink, visited.get(sId)!.lowLink);
+      } else if (visited.get(sId)!.onStack) {
+        entry.lowLink = Math.min(entry.lowLink, visited.get(sId)!.index);
+      }
+    }
+
+    if (entry.lowLink === entry.index) {
+      const cmpt: Path = [];
+      let tId: NodeId;
+      do {
+        tId = stack.pop()!;
+        visited.get(tId)!.onStack = false;
+        cmpt.push(tId);
+      } while (id !== tId);
+      results.push(cmpt);
+    }
+  }
+
+  for (const id of g.nodes) {
+    dfs(id);
+  }
+
+  return results;
+}
+
+/**
+ * Return a list of all lists of nodes involved in cycles.
+ */
+export function findCycles(g: SmartGraph<unknown, unknown>): Path[] {
+  return tarjan(g).filter(
+    (c) => c.length > 1 || (c.length === 1 && g.hasEdge({ source: c[0], target: c[0] })),
+  );
+}

package/src/tsabre/builder.ts

@@ -0,0 +1,97 @@
+import { assertExists } from "../assert.ts";
+import type { Edge, GraphData, Node, NodeId, SmartGraph } from "../types.ts";
+
+import { GRAPH_ROOT, TsabreGraph } from "./graph.ts";
+
+/**
+ * Given a set of graph-like data, instantiate a full graph.
+ *
+ * Takes an optional trackSegments parameter which is passed on to the
+ * underlying SmartGraph. When true, the SmartGraph will create segments for
+ * edges. When false, it will not.
+ */
+export function fromData<N extends Node, E extends Edge>(
+  data: GraphData<N, E>,
+  trackSegments = true,
+): SmartGraph<N, E> {
+  const graph = new TsabreGraph<N, E>({ trackSegments });
+  mergeData<N, E>(graph, data);
+  return graph;
+}
+
+/**
+ * Given a set of graph-like data, put all of it into an existing graph.
+ */
+export function mergeData<N extends Node, E extends Edge>(
+  graph: SmartGraph<N, E>,
+  data: GraphData<N, E>,
+): void {
+  const nodes = new Map<string, N>([...data.nodes].map((node) => [node.id, node]));
+  const addNode = (nodeId: NodeId) => {
+    if (graph.hasNode(nodeId) || !nodes.has(nodeId)) {
+      return;
+    }
+    const node = assertExists(nodes.get(nodeId));
+    graph.setNode(nodeId, node);
+    if (node.parent) {
+      addNode(node.parent);
+      graph.setParent(node.id, node.parent);
+    }
+  };
+
+  for (const id of nodes.keys()) {
+    addNode(id);
+  }
+
+  for (const edge of data.edges) {
+    const [source, target, name] = [edge.source, edge.target, edge.name];
+    graph.setEdge({ source, target, name }, edge);
+  }
+}
+
+/**
+ * Given a graph and a function taking a node id and value which returns a
+ * boolean, construct a new graph with only those nodes matching the
+ * filter function, and only edges between those filtered nodes. Nodes
+ * whose parent is missing will be promoted to the next parent up,
+ * possibly being the graph root.
+ */
+export function filterNodes<N extends Node, E extends Edge>(
+  g: SmartGraph<N, E>,
+  fn: (value: N) => boolean,
+): SmartGraph<N, E> {
+  const graph = new TsabreGraph<N, E>();
+  // Copy nodes
+  for (const value of g.allNodes) {
+    if (fn(value)) {
+      graph.setNode(value.id, value);
+    }
+  }
+
+  // Copy edges
+  for (const edge of g.allEdges) {
+    if (graph.hasNode(edge.source) && graph.hasNode(edge.target)) {
+      graph.setEdge(edge, g.edge(edge)!);
+    }
+  }
+
+  // Copy parents
+  const parents = new Map<NodeId, NodeId>();
+  const findParent = (id: NodeId): NodeId => {
+    const parent = g.parent(id);
+    if (parent === GRAPH_ROOT || graph.hasNode(parent)) {
+      parents.set(id, parent);
+      return parent;
+    } else if (parents.has(parent)) {
+      return parents.get(parent)!;
+    } else {
+      return findParent(parent);
+    }
+  };
+
+  for (const id of graph.nodes) {
+    graph.setParent(id, findParent(id));
+  }
+
+  return graph;
+}

package/src/tsabre/compress.ts

@@ -0,0 +1,15 @@
+/**
+ * @fileoverview Functions for compressings/decompressing strings.
+ */
+
+// DOIT(dsouther): Find a zlib impl
+
+/** Compresses a string to a base64 representation of deflated content. */
+export function deflate(str: string): string {
+  return Buffer.from(str, "utf8").toString("base64");
+}
+
+/** Decompresses a string from a base64 representation of deflated content. */
+export function inflate(b64: string): string {
+  return Buffer.from(b64, "base64").toString("utf8");
+}

package/src/tsabre/dijkstra/dijkstra.ts

@@ -0,0 +1,76 @@
+import { assertExists } from "../../assert.ts";
+import type { Edge, NodeId, SmartGraph } from "../../types.ts";
+import { edgeId } from "../graph.ts";
+import { Heap } from "./heap.ts";
+
+/**
+ * A node in the Dijkstra search. Will have a distance from the source node and
+ * which node would precede it on the shortest path. If the node is the source,
+ * it will have no predecessor and distance 0. If the node is unconnected, it
+ * will have no predecessor and distance POSITIVE_INFINITY.
+ */
+export interface PathNode {
+  distance: number;
+  predecessor?: NodeId;
+}
+
+/**
+ * From a starting node in a graph, return a table of PathNode entries for every
+ * node in the graph. Takes an optional weight function (default to constant 1)
+ * and an optional edge function (defaults to outedges of a node).
+ *
+ * Utilizes a straightforward Dijkstra variant, tracking the unsettled nodes in
+ * a heap-based priority queue. The algorithm thus runs in O(E + NlogN), and of
+ * course utilizes O(N) space.
+ */
+export function dijkstra(
+  g: SmartGraph<unknown, Edge>,
+  source: NodeId,
+  weightFn: (e: Edge) => number = () => 1,
+  edgeFn: (id: NodeId) => Iterable<Edge> = (id: NodeId) => g.outEdges(id),
+): Map<NodeId, PathNode> {
+  const results = new Map<NodeId, PathNode>();
+  const pq = new Heap<string>();
+
+  // Initialize the PQ with the source at 0 and all other nodes at infinity
+  for (const node of g.nodes) {
+    const distance = node === source ? 0 : Number.POSITIVE_INFINITY;
+    results.set(node, { distance });
+    pq.insert(distance, node);
+  }
+
+  while (!pq.isEmpty) {
+    // first iteration will always start with source, later iterations will
+    // find the next closest unsettled node.
+    const currentId = assertExists(pq.pop())[1];
+    const currentHop = assertExists(results.get(currentId));
+
+    // If the distance is infinity, this node never got visited in the search,
+    // and all other nodes left in the PQ are also unconnected. Stop early.
+    if (currentHop.distance === Number.POSITIVE_INFINITY) break;
+
+    const edges = edgeFn(currentId); // For debugging, store locally
+    for (const edge of edges) {
+      // Figure out which side is the other end of the edge, and load its hop.
+      const nextId = edge.source === currentId ? edge.target : edge.source;
+      const nextHop = assertExists(results.get(nextId), `${nextId} not in graph`);
+
+      // Negative weights break priority queues and Dijkstra.
+      const weight = weightFn(edge);
+      if (weight < 0) {
+        throw new Error(`disjkstra requires positive weights, got ${weight} on ${edgeId(edge)}`);
+      }
+
+      // Update the current hop, if this edge is shorter than its current
+      // distance.
+      const distance = currentHop.distance + weight;
+      if (distance < nextHop.distance) {
+        nextHop.distance = distance;
+        nextHop.predecessor = currentId;
+        pq.insert(distance, nextId);
+      }
+    }
+  }
+
+  return results;
+}

package/src/tsabre/dijkstra/heap.ts

@@ -0,0 +1,83 @@
+import { assert } from "../../assert.ts";
+
+export class Heap<Value = undefined> {
+  private index = 0;
+  private heap: Array<[number, Value]>;
+
+  get size(): number {
+    return this.index;
+  }
+
+  get isEmpty(): boolean {
+    return this.index === 0;
+  }
+
+  constructor(capacity = 15) {
+    this.heap = new Array(capacity);
+  }
+
+  insert(priority: number, value: Value): void {
+    assert(!isNaN(priority), "AssertionError: heap priority must be defined");
+    this.heap[this.index] = [priority, value];
+
+    // Shuffle up
+    let i = this.index,
+      p = parent(i);
+    while (i > 0 && this.heap[i][0] < this.heap[p][0]) {
+      const t = this.heap[p];
+      this.heap[p] = this.heap[i];
+      this.heap[i] = t;
+      i = p;
+      p = parent(i);
+    }
+
+    this.index += 1;
+  }
+
+  peek(): [number, Value] | undefined {
+    return this.heap[0];
+  }
+
+  pop(): [number, Value] | undefined {
+    if (this.isEmpty) return undefined;
+    const ret = this.heap[0];
+    this.index -= 1;
+    this.heap[0] = this.heap[this.index];
+    delete this.heap[this.index];
+
+    // Shuffle down
+    let i = 0;
+    while (i < this.index) {
+      const m = this.heap[i][0];
+      const li = left(i);
+      const ri = right(i);
+
+      const l = this.heap[li]?.[0] ?? Number.POSITIVE_INFINITY;
+      const r = this.heap[ri]?.[0] ?? Number.POSITIVE_INFINITY;
+
+      const ni = m > l ? (l > r ? ri : li) : m > r ? (l > r ? ri : li) : i;
+      if (ni === i) {
+        break;
+      }
+
+      const t = this.heap[ni];
+      this.heap[ni] = this.heap[i];
+      this.heap[i] = t;
+      i = ni;
+    }
+
+    return ret;
+  }
+}
+
+function parent(i: number): number {
+  return Math.floor((i - 1) / 2);
+}
+
+function left(i: number): number {
+  return i * 2 + 1;
+}
+
+function right(i: number): number {
+  return i * 2 + 2;
+}