pure/research/experiments/019-idle-links/transport.c, branch masterVerified execution runtime unifying state, persistence, and replication.
http://git.yeowoo.org/pure/atom?h=master2026-10-01T07:52:43ZPush a turn's sends to a link at once, and round only the links that want one (017, 2b-1)2026-10-01T07:52:43Zeunhhunecpition205@gmail.com2026-10-01T07:52:43Zurn:sha1:94e7bb87bce6821e91734f1fcbb6cfd61a008049
The sending loop was woken by every record queued while it slept: the
owner queues one by one, the loop caught up and slept between them, and
every link took a round on every wake. Four links sent 64k packets of
12 records where threads sent 40k of 20, and ran at 257k sends/s
against 581k. The owner now queues a turn's sends and pushes each link
once; the loop rounds a link only when its socket has answers, it was
pushed, or its time came.
Queue only the way to the receivers behind M6's bottleneck2026-09-29T07:30:30Zeunhhunecpition205@gmail.com2026-09-29T07:30:30Zurn:sha1:fb573903562695af47b63f91a9e96f55d0661d94
tbf with netem under it lost tbf's queue (netem became it), and the
answers queued behind the data. Now each way has its netem, the way to
the receivers' ports then a tbf whose queue holds a round trip; the way
back does not queue. transport.c takes its listener's port
(TRANSPORT_PORT).
Apply a link's records in transport.c as a host does2026-09-29T06:47:00Zeunhhunecpition205@gmail.com2026-09-29T06:47:00Zurn:sha1:d3328ebe3bb7133ad615f78d9800fe7e0d830bf2
From the one after the last heard, letting be the ones heard before and
stopping at a gap: the listener's first delivery may begin past it when
packets reorder, which the harness counted as wrong.
Measure a link on a path of loss, reordering and a bottleneck (M6 harness)2026-09-29T06:44:50Zeunhhunecpition205@gmail.com2026-09-29T06:44:50Zurn:sha1:6a72b5c8164ceb73994ab231a075cfb0ad1d7192
020-lossy-paths/run.py runs each case in an unprivileged namespace: a
50 Mbit/s tbf bottleneck under netem's delay, jitter and loss, both
ways. A link may send without UDP GSO (pure_link_gso), as netem takes a
burst as one packet; quinn the same (QUIC_GSO=0). transport.c and the
quinn harness give the records handed over in each 100 ms, and at a
steady rate the time each took; TCP CUBIC flows run beside them.
Keep a link's two sides as state alone, the sockets and threads apart2026-09-29T06:17:36Zeunhhunecpition205@gmail.com2026-09-29T06:17:36Zurn:sha1:7c6595c8a9229a2208ed5bd75b2dee249187923d
link/link-protocol.h is the protocol with no socket, thread or clock of
its own: packets and time in, packets out. link/link.h carries it over
UDP as before. A sender starts small (8 flights, 16 records, a 4 KiB
ring) so one thread can hold many. The transport's CPU a record is the
same within 2% (five rounds each way, 61 B to 16 KiB).
test-link runs both sides through a network of its own: loss, packets
held back and doubled, failed saves, an idle sweep, and both sides
starting again, every record applied once as sent.
Let links know nothing of the core: the host names inputs and shapes2026-09-29T06:11:32Zeunhhunecpition205@gmail.com2026-09-29T06:11:32Zurn:sha1:fcf7cdbe0a971825da0bb087383c60e714ab2be0
A sender takes its messages' shape, and a listener asks its host which
input a stream goes to. The core gives the shape (pure_module_shape);
link/ now builds without the core's headers.
Send a record whole when it fits a packet, however many pieces it has2026-09-29T04:11:01Zeunhhunecpition205@gmail.com2026-09-29T04:11:01Zurn:sha1:41cbb5631fd12dc223738de65246af1a69761bea
A record over a piece (1,000 bytes) went in pieces even when it fit the
packet whole: a record of 1,013 bytes went as two RECORD frames, and the
receiver gathered it the slow way (an allocation, pieces, then onto the
line). A record none of whose pieces went yet now goes whole in a RECORDS
frame whenever it fits what is left of the packet; its pieces are marked
sent together. A record too large for a packet, or one resent after
some of its pieces were lost, still goes in pieces, and a receiver takes
a record whole or in pieces alike.
The transport alone takes 2.85 us a record of 1,013 bytes, not 3.18
(quinn: 3.90). transport.c now checks every record delivered: in order,
once each, its bytes as sent. None was wrong in a network namespace with
1 ms of delay, 3 % loss and 10 % reordering, with records of 61, 1,013
and 16,013 bytes.
Wake a link's thread only when it sleeps, once2026-09-28T19:10:49Zeunhhunecpition205@gmail.com2026-09-28T19:10:49Zurn:sha1:ee7f97001b0e193a766a0f889ae16f9d5af40fea
Every queued record wrote the link's eventfd, a system call each, and woke
the thread to send a packet of a few records. A record queued now wakes
the thread only when it sleeps and nobody woke it yet; one queued while it
sends marks the link, and the thread looks again before it sleeps. With
records queued one at a time as fast as a thread can, 200,000 small ones
went at 400k a second, and now at 730k; queuing one costs 0.43 us, not
1.0.
research/experiments/019-idle-links/transport.c measures the transport
alone: a link and a listener in one process, no app, no store. A backlog
of 200,000 records of 61 bytes drains at 3 to 4 million a second, 0.24 us
a record on each side.