ipcpd: Rework congestion avoidance

Congestion avoidance is a property of the layer, orthogonal to ARQ
and to flow control: FRCP retransmits and lets the peer pace the
sender, per flow, end-to-end; the IPCP paces path aggregates. Each
signal means one thing: a loss triggers a retransmission, a mark
means congestion, the peer window means a slow receiver. Every flow
is paced by the same rate law whatever its QoS, so a greedy raw
sender shares a bottleneck fairly with a reliable stream.

The unit of control is the (destination address, QoS cube)
aggregate: all flows toward that destination share one controller
and one rate; a start-time fair-queuing pacer divides the rate
across them by deadline instead of blocking the send path, and a
new flow rides the aggregate's estimates at its current rate, with
no probing of its own. Slow start runs once per aggregate.

The congestion signal is a multi-bit magnitude: forwarders mark
packets with their standing queue depth, MAX-combined across hops,
so a packet carries the deepest queue on its path. The receiver
feeds back a time-integral mean over a window that adapts to the
flow's byte rate, measuring a slow flow with the same fidelity as a
fast one. The sender runs AIMD scaled by elapsed wall-clock time,
which makes the steady-state allocation RTT-independent.

The PCI gains one byte: the path capacity as a quarter-log2 code.
Forwarders estimate their egress rate from busy-period drain and
MIN-stamp the byte, the receiver returns the window minimum with
its feedback, and the sender scales its rate floor and additive
slope to the bottleneck (C / 32). A deep cut implies a backlogged
bottleneck and a backlogged bottleneck advertises its capacity, so
the scaled floor is live exactly when recovery needs it: the probe
heals a halving in seconds at any link rate, and the floor bounds
the deepest hole to a factor 32 below the bottleneck.

Signed-off-by: Dimitri Staessens <dimitri@ouroboros.rocks>
Signed-off-by: Sander Vrijders <sander@ouroboros.rocks>

1 files changed, 15 insertions, 13 deletions

diff --git a/src/ipcpd/unicast/ca.h b/src/ipcpd/unicast/ca.h
index 47ea15a0..d73d35f5 100644
--- a/src/ipcpd/unicast/ca.h
+++ b/src/ipcpd/unicast/ca.h
@@ -29,38 +29,40 @@
 #include <stdbool.h>
 #include <sys/types.h>
 
-typedef union {
-        time_t wait;
-} ca_wnd_t;
-
 int      ca_init(enum pol_cong_avoid ca);
 
 void     ca_fini(void);
 
 
 /* OPS */
-void *   ca_ctx_create(void);
+void *   ca_ctx_get(uint64_t  addr,
+                    qoscube_t qc);
 
-void     ca_ctx_destroy(void * ctx);
+void     ca_ctx_put(void * ctx);
 
-ca_wnd_t ca_ctx_update_snd(void * ctx,
-                           size_t len);
+time_t   ca_ctx_update_snd(void *     ctx,
+                           size_t     len,
+                           uint8_t    lecn,
+                           uint64_t * ftag);
 
 bool     ca_ctx_update_rcv(void *     ctx,
                            size_t     len,
                            uint8_t    ecn,
-                           uint16_t * ece);
+                           uint8_t    cap,
+                           uint16_t * ece,
+                           uint8_t *  fcap);
 
 void     ca_ctx_update_ece(void *   ctx,
-                           uint16_t ece);
+                           uint16_t ece,
+                           uint8_t  cap);
 
-void     ca_wnd_wait(ca_wnd_t wnd);
-
-int      ca_calc_ecn(int       fd,
+int      ca_calc_ecn(size_t    queued,
                      uint8_t * ecn,
                      qoscube_t qc,
                      size_t    len);
 
+bool     ca_marks_ecn(void);
+
 ssize_t  ca_print_stats(void * ctx,
                         char * buf,
                         size_t len);