admin/LithosAnanake
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(v4.0.0): the wire in the engine -- whole messages, put and taken in one step

Browse Source 
Queues of whole messages on the wires between nodes (v4/wire.h), the six
addresses and ten operations a node asks of the fabric (MESH.md 7d.3), and the
fabric's pool of queues. Engine only: the nucleus does not use any of it yet.
The ports in the host map move to BUF0_W - 140 so that the new addresses are
not among the nucleus variables, with a compile-time check.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
rajames
2026-10-08 13:50:15 -04:00
co-authored by Claude Opus 5.5
parent 50be766e7b
commit d5cd64605d
14 changed files with 1267 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files
v4/src/fabric.c
+236 -4
View File
@@ -9,7 +9,10 @@ static void clear_place(v4_place *p)
unsigned k;
p->node = 0;
p->asleep = 0;
for (k = 0; k < V4_PORTS; k++) { p->wire[k].kind = V4_WIRE_NONE; p->wire[k].node = 0; p->wire[k].port = 0; p->wire[k].device = 0; }
for (k = 0; k < V4_PORTS; k++) {
p->wire[k].kind = V4_WIRE_NONE; p->wire[k].node = 0; p->wire[k].port = 0; p->wire[k].device = 0;
p->wire[k].rx = 0; p->wire[k].tx = 0;
}
}
void v4_fabric_init(v4_fabric *f, v4_place *places, unsigned capacity)
@@ -17,6 +20,10 @@ void v4_fabric_init(v4_fabric *f, v4_place *places, unsigned capacity)
unsigned i;
f->place = places;
f->capacity = capacity;
f->queue = 0;
f->queue_count = 0;
f->queue_free = 0;
f->queue_first = 0;
f->gone_error = 0;
f->interrupt_error = 0;
for (i = 0; i < capacity; i++) clear_place(&places[i]);
@@ -65,34 +72,102 @@ static int there(const v4_fabric *f, unsigned id, unsigned port)
return id < f->capacity && f->place[id].node && port < V4_PORTS;
}
void v4_fabric_queues(v4_fabric *f, v4_wire_queue *pool, unsigned count)
{
unsigned i;
f->queue = pool;
f->queue_count = count;
f->queue_free = count;
f->queue_first = count ? 1 : 0;
for (i = 0; i < count; i++) {
v4_wire_reset(&pool[i]);
pool[i].head = i + 1 < count ? i + 2 : 0;
}
}
/* a queue that is not on a wire; the fabric has been given some, and there is one */
static v4_wire_queue *take_queue(v4_fabric *f)
{
v4_wire_queue *q = &f->queue[f->queue_first - 1];
f->queue_first = q->head;
f->queue_free--;
v4_wire_reset(q);
return q;
}
/* a queue comes off a wire: what was waiting on it is let go */
static void give_queue(v4_fabric *f, v4_wire_queue *q)
{
if (!q) return;
v4_wire_reset(q);
q->head = f->queue_first;
f->queue_first = (unsigned)(q - f->queue) + 1;
f->queue_free++;
}
/* Can the ports a and b be wired: if the fabric has been given queues, are
* there two once what those ports are wired to now has been given back? */
static int queues_for(const v4_fabric *f, unsigned a, unsigned pa, unsigned b, unsigned pb)
{
const v4_wire_queue *seen[4];
unsigned i, k, n = 0, back = 0;
if (!f->queue) return 1;
seen[n++] = f->place[a].wire[pa].rx; seen[n++] = f->place[a].wire[pa].tx;
if (b < f->capacity) { seen[n++] = f->place[b].wire[pb].rx; seen[n++] = f->place[b].wire[pb].tx; }
for (i = 0; i < n; i++) {
if (!seen[i]) continue;
for (k = 0; k < i && seen[k] != seen[i]; k++) { }
if (k == i) back++;
}
return f->queue_free + back >= 2;
}
/* cut what is on a port, at both ends */
static void cut(v4_fabric *f, unsigned a, unsigned pa)
{
v4_wire *w = &f->place[a].wire[pa];
if (w->kind == V4_WIRE_NODE && w->node < f->capacity && w->port < V4_PORTS) {
v4_wire *other = &f->place[w->node].wire[w->port];
if (other->kind == V4_WIRE_NODE && other->node == a && other->port == pa) { other->kind = V4_WIRE_NONE; other->device = 0; }
if (other->kind == V4_WIRE_NODE && other->node == a && other->port == pa) {
other->kind = V4_WIRE_NONE; other->device = 0;
other->rx = 0; other->tx = 0; /* the same two queues as w's */
}
}
if (f->queue) { give_queue(f, w->rx); give_queue(f, w->tx); }
w->kind = V4_WIRE_NONE;
w->device = 0;
w->rx = 0;
w->tx = 0;
}
int v4_fabric_wire(v4_fabric *f, unsigned a, unsigned pa, unsigned b, unsigned pb)
{
if (!there(f, a, pa) || !there(f, b, pb) || (a == b && pa == pb)) return 0;
if (!queues_for(f, a, pa, b, pb)) return 0;
cut(f, a, pa);
cut(f, b, pb);
f->place[a].wire[pa].kind = V4_WIRE_NODE; f->place[a].wire[pa].node = b; f->place[a].wire[pa].port = pb;
f->place[b].wire[pb].kind = V4_WIRE_NODE; f->place[b].wire[pb].node = a; f->place[b].wire[pb].port = pa;
if (f->queue) {
v4_wire_queue *ab = take_queue(f), *ba = take_queue(f);
f->place[a].wire[pa].tx = ab; f->place[b].wire[pb].rx = ab;
f->place[b].wire[pb].tx = ba; f->place[a].wire[pa].rx = ba;
}
return 1;
}
int v4_fabric_wire_device(v4_fabric *f, unsigned a, unsigned pa, const v4_device *device)
{
if (!there(f, a, pa) || !device) return 0;
if (!queues_for(f, a, pa, f->capacity, 0)) return 0;
cut(f, a, pa);
f->place[a].wire[pa].kind = V4_WIRE_DEVICE;
f->place[a].wire[pa].device = device;
if (f->queue) {
f->place[a].wire[pa].rx = take_queue(f); /* from the device */
f->place[a].wire[pa].tx = take_queue(f); /* to it */
}
return 1;
}
@@ -103,6 +178,25 @@ int v4_fabric_unwire(v4_fabric *f, unsigned a, unsigned pa)
return 1;
}
int v4_fabric_device_put(v4_fabric *f, unsigned node, unsigned port, const v4_cell *header7, const v4_cell *text)
{
const v4_wire *w;
if (!there(f, node, port)) return V4_WIRE_NO_ONE;
w = &f->place[node].wire[port];
if (w->kind != V4_WIRE_DEVICE || !w->rx) return V4_WIRE_NO_ONE;
return v4_wire_put(w->rx, header7, text);
}
int v4_fabric_device_take(v4_fabric *f, unsigned node, unsigned port, v4_cell *header7, v4_cell *text, unsigned text_cap)
{
const v4_wire *w;
if (!there(f, node, port)) return V4_WIRE_NO_ONE;
w = &f->place[node].wire[port];
if (w->kind != V4_WIRE_DEVICE || !w->tx) return V4_WIRE_NO_ONE;
v4_wire_first(w->tx); /* the device takes them in the order they were put */
return v4_wire_take(w->tx, header7, text, text_cap);
}
v4_fabric_node *v4_fabric_remove(v4_fabric *f, unsigned id)
{
v4_fabric_node *storage;
@@ -189,21 +283,159 @@ static void look_about(v4_fabric *f, unsigned a)
v4_node_port_status(&f->place[a].node->n, writers, readers);
}
/* ---- whole messages: what a node asked for by storing to Do (MESH.md 7d.3) ---- */
/* 1 if `count` words from `addr` are memory that is not the ports, or the
* addresses after them, of this node: they may be copied to and from. */
static int span_ok(const v4_node *n, v4_cell addr, unsigned count)
{
if (count == 0) return 1;
if (count > V4_NODE_WORDS || addr < 0 || (v4_ucell)addr > (v4_ucell)(V4_NODE_WORDS - count)) return 0;
if (n->port >= 0 && addr <= n->port + (v4_cell)V4_PORT_HAVE && addr + (v4_cell)count > n->port) return 0;
return 1;
}
/* the queue of messages that come to the node's wire, and that go from it; 0: no one is on it */
static v4_wire_queue *coming(const v4_fabric *f, unsigned id, unsigned port)
{
return port < V4_PORTS ? f->place[id].wire[port].rx : 0;
}
static v4_wire_queue *going(const v4_fabric *f, unsigned id, unsigned port)
{
return port < V4_PORTS ? f->place[id].wire[port].tx : 0;
}
/* has a message come to any of the node's wires since it last fetched which have one */
static int arrived(const v4_fabric *f, unsigned id)
{
unsigned k;
for (k = 0; k < V4_PORTS; k++) {
const v4_wire_queue *q = f->place[id].wire[k].rx;
if (q && q->arrived) return 1;
}
return 0;
}
/* Node `id` is doing an operation. Returns 1 and puts how it went in
* *how, or returns 0: it waits (8 and 9 only). Nothing is copied, put or
* taken unless the answer is 0 -- done. */
static int operate(v4_fabric *f, unsigned id, v4_cell *how)
{
v4_node *n = &f->place[id].node->n;
v4_wire_queue *rx = coming(f, id, n->wire), *tx = going(f, id, n->wire), *to;
v4_cell a = n->wire_a, b = n->wire_b, h[V4_WIRE_HEADER];
unsigned cells;
switch (n->do_op) {
case 1: /* look */
if (!rx) { *how = V4_WIRE_NO_ONE; break; }
if (rx->mark >= rx->used) { *how = V4_WIRE_NO_MESSAGE; break; }
if (!span_ok(n, a, V4_WIRE_HEADER)) { *how = V4_WIRE_NOT_A_MESSAGE; break; }
*how = v4_wire_look(rx, &n->mem[a]);
break;
case 2: /* take */
if (!rx) { *how = V4_WIRE_NO_ONE; break; }
if (rx->mark >= rx->used) { *how = V4_WIRE_NO_MESSAGE; break; }
(void)v4_wire_look(rx, h);
cells = v4_wire_cells(h[6]) - V4_WIRE_HEADER;
if (!span_ok(n, a, V4_WIRE_HEADER) || !span_ok(n, b, cells)) { *how = V4_WIRE_NOT_A_MESSAGE; break; }
*how = v4_wire_take(rx, &n->mem[a], cells ? &n->mem[b] : &n->mem[0], cells);
break;
case 3: /* move */
if (!rx) { *how = V4_WIRE_NO_ONE; break; }
if (rx->mark >= rx->used) { *how = V4_WIRE_NO_MESSAGE; break; }
to = a >= 0 && a < (v4_cell)V4_PORTS ? going(f, id, (unsigned)a) : 0;
*how = to ? v4_wire_move(rx, to) : V4_WIRE_NO_ONE;
break;
case 4: /* drop */
*how = rx ? v4_wire_drop(rx) : V4_WIRE_NO_ONE;
break;
case 5: /* put */
if (!tx) { *how = V4_WIRE_NO_ONE; break; }
if (!span_ok(n, a, V4_WIRE_HEADER)) { *how = V4_WIRE_NOT_A_MESSAGE; break; }
cells = v4_wire_cells(n->mem[a + 6]);
if (cells == 0 || !span_ok(n, b, cells - V4_WIRE_HEADER)) { *how = V4_WIRE_NOT_A_MESSAGE; break; }
*how = v4_wire_put(tx, &n->mem[a], cells > V4_WIRE_HEADER ? &n->mem[b] : &n->mem[0]);
break;
case 6: /* first */
if (rx) v4_wire_first(rx);
*how = rx ? V4_WIRE_DONE : V4_WIRE_NO_ONE;
break;
case 7: /* next */
*how = rx ? v4_wire_next(rx) : V4_WIRE_NO_ONE;
break;
case 8: /* sleep */
if (!arrived(f, id)) return 0;
*how = V4_WIRE_DONE;
break;
case 9: /* sleep for room */
if (!tx) { *how = V4_WIRE_NO_ONE; break; }
if (a < 0) { *how = V4_WIRE_NOT_A_MESSAGE; break; }
if (a <= (v4_cell)V4_WIRE_CELLS && v4_wire_room(tx, (unsigned)a) == V4_WIRE_DONE) { *how = V4_WIRE_DONE; break; }
if (!arrived(f, id)) return 0;
*how = V4_WIRE_NO_ROOM;
break;
case 10: /* room */
if (!tx) { *how = V4_WIRE_NO_ONE; break; }
if (a < 0) { *how = V4_WIRE_NOT_A_MESSAGE; break; }
*how = a <= (v4_cell)V4_WIRE_CELLS ? v4_wire_room(tx, (unsigned)a) : V4_WIRE_NO_ROOM;
break;
default: /* not an operation */
*how = V4_WIRE_NOT_A_MESSAGE;
break;
}
return 1;
}
unsigned v4_fabric_step(v4_fabric *f)
{
unsigned i, done = 0;
unsigned i, k, done = 0;
/* which of its wires have a message waiting, for each node to fetch */
for (i = 0; i < f->capacity; i++)
if (awake(f, i)) {
unsigned have = 0;
for (k = 0; k < V4_PORTS; k++) {
const v4_wire_queue *q = f->place[i].wire[k].rx;
if (q && q->used > 0) have |= 1u << k;
}
v4_node_have(&f->place[i].node->n, have);
}
/* a node that is blocked fetches nothing, and is looked about for when
* it is next to execute */
for (i = 0; i < f->capacity; i++)
if (awake(f, i)) {
const v4_node *n = &f->place[i].node->n;
if (!n->stopped && !n->asking && !(n->reading && !n->given)) look_about(f, i);
if (!n->stopped && !n->asking && !n->doing && !(n->reading && !n->given)) look_about(f, i);
}
for (i = 0; i < f->capacity; i++)
if (awake(f, i)) done += v4_exec_step_word(&f->place[i].node->n, &f->place[i].node->es, &f->place[i].node->h);
/* a node that fetched which wires have a message has seen what had come */
for (i = 0; i < f->capacity; i++)
if (awake(f, i) && f->place[i].node->n.have_fetched) {
for (k = 0; k < V4_PORTS; k++)
if (f->place[i].wire[k].rx) f->place[i].wire[k].rx->arrived = 0;
f->place[i].node->n.have_fetched = 0;
}
/* the operations on the wires, each whole; the two that wait are looked at last, so that
* what every other node has put or taken this step has been, whatever their numbers */
for (i = 0; i < f->capacity; i++)
if (awake(f, i) && f->place[i].node->n.doing && f->place[i].node->n.do_op != 8 && f->place[i].node->n.do_op != 9) {
v4_cell how;
(void)operate(f, i, &how);
v4_node_done(&f->place[i].node->n, how);
done++;
}
for (i = 0; i < f->capacity; i++)
if (awake(f, i) && f->place[i].node->n.doing) {
v4_cell how;
if (operate(f, i, &how)) { v4_node_done(&f->place[i].node->n, how); done++; }
}
for (i = 0; i < f->capacity; i++)
if (awake(f, i) && f->place[i].node->n.asking) done += hand_over_write(f, i);
for (i = 0; i < f->capacity; i++)