The assigner and the node-engine on one node waited for each other for ever: the assigner's want in step compose for the new node-engine, the node-engine's in step place for the new assigner, and the cycle check counted one step at a time, so nothing said it. The node-engine's own want (the holder of the seat node-engine on the node, read from the acting edges' seat) is now held by no acting edge, so it is written first and the node's other wants, the assigner's own included, wait for it. Cycles finds a cycle across steps as well as within one, and a want held on a cycle no rule breaks is the finding acting-cycle (scope module, id <node>.<module>), naming each edge's step, cleared by the next pass that finds it on none. Builds: design 47 G §49, §268, §272, A-323, A-330 Claude-Session: https://claude.ai/code/session_01NcbgfGKaxw984XyAPfLm4h
235 lines
6.8 KiB
Go
235 lines
6.8 KiB
Go
package assigngraph
|
|
|
|
import (
|
|
"fmt"
|
|
"maps"
|
|
"slices"
|
|
"strings"
|
|
|
|
"git.novox.be/novox/mesh-contracts/go/seats/nodeengine"
|
|
"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshwants"
|
|
)
|
|
|
|
// Cycles are the cycles among the acting waits (design 47 G §272, ADR 0656, A-323): an entry waits for its acting parts in the step
|
|
// an edge names, so acting parts that wait for each other, in one step or across steps, wait for ever unless a rule breaks the
|
|
// cycle. A cycle within one step is `<step>: a -> b -> a`; one across steps names each edge's step, `a -[compose]-> b -[place]-> a`;
|
|
// each by node and module, said once from its smallest member, sorted. A holder's own inputs are no edge here (the graph gives an
|
|
// acting edge only from a part to the entries it acts on, never to what the part is built from).
|
|
func Cycles(entries []meshwants.AssignmentEntry) []string {
|
|
type key struct{ step, at string }
|
|
next := map[key][]string{}
|
|
steps := map[string]bool{}
|
|
for _, e := range entries {
|
|
for _, edge := range e.Edges {
|
|
if edge.Kind != EdgeActing {
|
|
continue
|
|
}
|
|
k := key{edge.Step, e.Node + "/" + e.Module}
|
|
next[k] = append(next[k], edge.Node+"/"+edge.Module)
|
|
steps[edge.Step] = true
|
|
}
|
|
}
|
|
var out []string
|
|
for _, step := range slices.Sorted(maps.Keys(steps)) {
|
|
const (
|
|
open = iota + 1
|
|
done
|
|
)
|
|
state := map[string]int{}
|
|
var path []string
|
|
var walk func(at string)
|
|
walk = func(at string) {
|
|
state[at] = open
|
|
path = append(path, at)
|
|
for _, to := range next[key{step, at}] {
|
|
switch state[to] {
|
|
case 0:
|
|
walk(to)
|
|
case open:
|
|
from := slices.Index(path, to)
|
|
cycle := slices.Clone(path[from:])
|
|
// start at the smallest member so one cycle is said once, whichever member is met first
|
|
lowest := slices.Index(cycle, slices.Min(cycle))
|
|
cycle = append(cycle[lowest:], cycle[:lowest]...)
|
|
out = append(out, fmt.Sprintf("%s: %s -> %s", step, strings.Join(cycle, " -> "), cycle[0]))
|
|
}
|
|
}
|
|
path = path[:len(path)-1]
|
|
state[at] = done
|
|
}
|
|
starts := map[string]bool{}
|
|
for k := range next {
|
|
if k.step == step {
|
|
starts[k.at] = true
|
|
}
|
|
}
|
|
for _, at := range slices.Sorted(maps.Keys(starts)) {
|
|
if state[at] == 0 {
|
|
walk(at)
|
|
}
|
|
}
|
|
}
|
|
// Across steps (A-323): the shortest cycle through each entry over every acting edge, said when its edges name two steps or more.
|
|
for _, hops := range cyclesThrough(entries, func(_ meshwants.AssignmentEntry, e meshwants.Edge) bool { return e.Kind == EdgeActing }) {
|
|
if crossesSteps(hops) {
|
|
out = append(out, hopWords(rotated(hops)))
|
|
}
|
|
}
|
|
slices.Sort(out)
|
|
return slices.Compact(out)
|
|
}
|
|
|
|
// HeldCycles is, by `<node>/<module>`, the cycle each entry lies on among the edges holds says hold it (A-323, A-330): a want held
|
|
// on such a cycle is held for ever, since no rule breaks it. Each cycle starts at the entry and names each edge's step.
|
|
func HeldCycles(entries []meshwants.AssignmentEntry, holds func(e meshwants.AssignmentEntry, edge meshwants.Edge) bool) map[string]string {
|
|
out := map[string]string{}
|
|
for at, hops := range cyclesThrough(entries, holds) {
|
|
out[at] = hopWords(hops)
|
|
}
|
|
return out
|
|
}
|
|
|
|
// Engines is, by node, the module that holds the seat node-engine there, read from the acting edges' seat (A-330).
|
|
func Engines(entries []meshwants.AssignmentEntry) map[string]string {
|
|
out := map[string]string{}
|
|
for _, e := range entries {
|
|
for _, edge := range e.Edges {
|
|
if edge.Kind == EdgeActing && edge.Seat == nodeengine.Seat {
|
|
out[edge.Node] = edge.Module
|
|
}
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
// hop is one edge of a cycle: from the entry at, in step, to the next hop's entry.
|
|
type hop struct{ at, step string }
|
|
|
|
// cyclesThrough is, by `<node>/<module>`, the shortest cycle through each entry over the edges keep takes, found within the
|
|
// entry's strongly connected part, each starting at the entry.
|
|
func cyclesThrough(entries []meshwants.AssignmentEntry, keep func(meshwants.AssignmentEntry, meshwants.Edge) bool) map[string][]hop {
|
|
type out struct{ to, step string }
|
|
next := map[string][]out{}
|
|
for _, e := range entries {
|
|
at := e.Node + "/" + e.Module
|
|
for _, edge := range e.Edges {
|
|
if keep(e, edge) {
|
|
next[at] = append(next[at], out{edge.Node + "/" + edge.Module, edge.Step})
|
|
}
|
|
}
|
|
}
|
|
for at := range next {
|
|
slices.SortFunc(next[at], func(a, b out) int { return strings.Compare(a.to+"\x00"+a.step, b.to+"\x00"+b.step) })
|
|
}
|
|
part := strongParts(slices.Sorted(maps.Keys(next)), func(at string) []string {
|
|
var to []string
|
|
for _, o := range next[at] {
|
|
to = append(to, o.to)
|
|
}
|
|
return to
|
|
})
|
|
found := map[string][]hop{}
|
|
for _, start := range slices.Sorted(maps.Keys(next)) {
|
|
// breadth first from start back to it, within its part
|
|
prev := map[string]hop{}
|
|
queue := []string{start}
|
|
seen := map[string]bool{}
|
|
for len(queue) > 0 && found[start] == nil {
|
|
at := queue[0]
|
|
queue = queue[1:]
|
|
for _, o := range next[at] {
|
|
if part[o.to] != part[start] {
|
|
continue
|
|
}
|
|
if o.to == start {
|
|
hops := []hop{{at, o.step}}
|
|
for cur := at; cur != start; {
|
|
h := prev[cur]
|
|
hops = append(hops, h)
|
|
cur = h.at
|
|
}
|
|
slices.Reverse(hops)
|
|
found[start] = hops
|
|
break
|
|
}
|
|
if !seen[o.to] {
|
|
seen[o.to] = true
|
|
prev[o.to] = hop{at, o.step}
|
|
queue = append(queue, o.to)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return found
|
|
}
|
|
|
|
// strongParts numbers each vertex by its strongly connected part (Tarjan).
|
|
func strongParts(vertices []string, succ func(string) []string) map[string]int {
|
|
index, low, part := map[string]int{}, map[string]int{}, map[string]int{}
|
|
on := map[string]bool{}
|
|
var stack []string
|
|
n, parts := 0, 0
|
|
var visit func(v string)
|
|
visit = func(v string) {
|
|
index[v], low[v] = n, n
|
|
n++
|
|
stack = append(stack, v)
|
|
on[v] = true
|
|
for _, w := range succ(v) {
|
|
if _, ok := index[w]; !ok {
|
|
visit(w)
|
|
low[v] = min(low[v], low[w])
|
|
} else if on[w] {
|
|
low[v] = min(low[v], index[w])
|
|
}
|
|
}
|
|
if low[v] == index[v] {
|
|
parts++
|
|
for {
|
|
w := stack[len(stack)-1]
|
|
stack = stack[:len(stack)-1]
|
|
on[w] = false
|
|
part[w] = parts
|
|
if w == v {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for _, v := range vertices {
|
|
if _, ok := index[v]; !ok {
|
|
visit(v)
|
|
}
|
|
}
|
|
return part
|
|
}
|
|
|
|
func crossesSteps(hops []hop) bool {
|
|
for _, h := range hops[1:] {
|
|
if h.step != hops[0].step {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// rotated is the cycle started at its smallest member, so one cycle is said once.
|
|
func rotated(hops []hop) []hop {
|
|
lowest := 0
|
|
for i, h := range hops {
|
|
if h.at < hops[lowest].at {
|
|
lowest = i
|
|
}
|
|
}
|
|
return append(slices.Clone(hops[lowest:]), hops[:lowest]...)
|
|
}
|
|
|
|
// hopWords is a cycle with each edge's step: `a -[compose]-> b -[place]-> a`.
|
|
func hopWords(hops []hop) string {
|
|
var b strings.Builder
|
|
for _, h := range hops {
|
|
fmt.Fprintf(&b, "%s -[%s]-> ", h.at, h.step)
|
|
}
|
|
return b.String() + hops[0].at
|
|
}
|