Controlling Adaptive HARQ Erasure Coding for Real-Time Transport Under Channel Model Mismatch

Shannon’s channel coding theorem [38] states that given a discrete memoryless channel, we can transmit information at a rate approaching the channel capacity arbitrarily close as the block-length of the block code approaches infinity, thus achieving high bandwidth efficiency. Such long block codes mean we also need a correspondingly long time to correct an error. If we consider hard deadlines, we instead want to correct errors within the deadline constraint to achieve some reliability in that limited time. Real-time systems, which impose hard deadlines, are therefore forced to operate away from the asymptotic regime and into the finite-blocklength regime. Thus, we have to accept the inherent gap between Shannon’s channel capacity and achievable rate [34], meaning that under a hard deadline constraint, we cannot correct every erasure pattern of the underlying channel. Still, the goal remains to approach the channel capacity as close as possible to efficiently use the channel network resources.

The core design philosophy of PRRT is to provide applications with datagram transport which satisfies a target packet loss rate ($P_T$) under a hard deadline constraint ($D_T$), while using minimal redundancy information (RI). To accomplish this, PRRT uses an adaptive HARQ erasure coding scheme that combines the benefits of FEC (low latency) and ARQ (RI efficiency). Adapting the erasure coding scheme requires observing and modelling the underlying channel. We choose a (piecewise) IID model with packet loss rate $P_e$ as our intermediate representation. The choice of such a simple model is intentional: its low sample complexity allows us to quickly adapt to distribution shifts through frequent re-estimation, making more complex alternatives, such as the Simplified Gilbert-Elliott (SGE) model, unnecessary in practice (see Figure 4-A). Additionally, using a simple model is a requirement to sustain real-time performance on constrained devices, as deriving high-quality (e.g., low RI) coding configurations can be prohibitively costly when not optimized [15, 32].

Minimizing the RI is a core design objective of PRRT, which, with the addition of a hard deadline constraint, makes Maximum Distance Separable (MDS) codes a strong choice. MDS codes by construction are erasure codes that achieve the Singleton bound, which means given $k$ source symbols and a block length $n$, resulting in $p=n-k$ parity symbols, we can recover from any $n-k=p$ erasures. This allows us to define the code rate of an MDS code as $\frac{k}{n}$.

Specifically, PRRT uses a systematic MDS code over the field $GF(2^8)$ with a $k\times n$ generator matrix $G=[I_k|A]$, where $A$ is a $k\times (n-k)$ Cauchy matrix with entries $a_{ij}=\frac{1}{x_i-y_j}$ with $x_i-y_j\ne 0$, $1\le i\le k$, and $1\le j\le n-k$. Since this MDS scheme operates over $GF(2^8)$, its symbols are bytes. We can extend this to a packet erasure coding scheme by applying $G$ byte-by-byte across the $k$ source packets.

PRRT implements a scheduled hybrid erasure coding scheme, which defines a code schedule as the triplet $(k,n,N_P)$, over $k$ source packets, block length $n$ and ARQ parity schedule $N_P=[N_P[0],N_P[1],\mathrm{\dots },N_P[N_C]]$. The parity schedule describes the distribution of parity packets across ARQ cycles, with $N_P[0]$ being proactive, and the total parity $p$ satisfying $p={\sum }_{i=0}^{N_C}{N}_P[i]=n-k$.

Finding the optimal coding schedule requires finding the schedule that incurs minimal redundancy information overhead while satisfying the application loss constraint $P_T$ and the application delay constraint $D_T$. Thus, we need to define the duration, effective loss rate and redundancy information of PRRT’s HARQ coding configurations.

The total duration of a block depends on the arrival time of the first source packet and the application deadline constraint, as well as the round-trip time (RTT), which we split into an accumulation (FEC) and an ARQ phase (Adapted from [32] Equation 3.16) with

where $T_s$ is the source packet interval, $P_L$ is the packet length, $R_C$ the datarate, $D_{RS}$ the response delay of the receiver and $D_{PL}$ the packet loss detection delay.

Given the IID channel model, we can compute the effective loss rate (Adapted from [32] Equation 3.17) of our coding schedule $(k,n,N_P)$ as

where $P_d$ is the hypergeometric distribution, and $P_m$ is the probability mass function of the binomial distribution.

We define the effective redundancy information of a coding configuration as the expected number of parity packets per source packet over the existing environment. The effective redundancy information of a schedule decays exponentially when ARQ cycles are available, since the probability of the next cycle triggering depends on the probability of the previous cycle $c$ accumulating less than $k$ packets $P_{fail}(c)$. This directly corresponds to the incremental redundancy nature of ARQ schemes, which use exponentially lower RI than pure FEC schemes (Adapted from [32] Equation 3.11).

Real-world packetized communication channels, especially IP networks, consist of many individual (next-hop) links that provide the foundation of the IP layer’s global routing. As a consequence, the network can grow almost indefinitely, and independently of the underlying physical implementation. However, while wired connections are relatively stable, wireless connections often implement their own stacks to provide the link reliability required for modern transport protocols to work efficiently. Congestion is a second, and arguably more prevalent, source of packet losses in IP networks. It is caused by the shared nature of communication links, which have a limited capacity and drop packets when saturated.

Due to these complex underlying channel dynamics, the channel process is not fully observable in such real-world networks. Moreover, even if we could fully observe it, recovering it exactly is computationally infeasible in general [13, 23]. Instead, we lean into the strengths of simple estimators, most notably the relatively low sample complexity of an IID Bernoulli process ($P_e$), to provide responsive, transient channel-state measurements. This results in modelling the channel as piecewise IID, where frequent re-estimation remains reasonably accurate across varying channel conditions. Our goal is to derive a value that represents the channel’s current (instantaneous) packet loss rate $P_I$. PRRT estimates channel loss by observing the sequence numbers of arriving source packets at the receiver. This measure is designed to retain statistical significance regardless of the source packet interval $T_s$. While, from a channel-coherence perspective, the instantaneous packet loss rate $P_I$ would arguably be undefined when the passively observed slice of network behaviour is too small, we instead treat it as always defined, proportional to that slice.

This simple estimator for $P_I$, individually fails to accurately capture long-term channel dynamics, including the low-packet-loss-rate domain and non-IID packet loss patterns. To address this model mismatch problem, we require a separate mechanism that stabilizes our system. Thus, we introduce a closed-loop controller that compensates for the limitations of the underlying model.

Controlling adaptive erasure coding requires us to bridge the gap between the most recent instantaneous channel-state estimations and the global objective of converging the end-to-end packet loss rate $P_{E2E}$ towards the target packet loss rate $P_T$. First, we must consider the environment we operate in and the control inputs we have. Figure 1 gives an overview of the control architecture and shows how it arrives at the coding parameters $(k,n,N_P)$ by adapting to network conditions observed from feedback packets. The transport layer controller operates directly below the sender application, which also defines the target constraints, including the target packet loss rate. Time-related statistics, such as the $RTT$ and source interval $T_s$, are also estimated at the sender-side transport layer. The packet loss estimation for the instantaneous channel packet loss rate $P_I$ and end-to-end packet loss rate $P_{E2E}$ is part of the receiver, and thus arrives at the sender via feedback with a delay of roughly $\frac{RTT}{2}$. Note that $P_{E2E}$ is further delayed by our deadline constraint $D_T$, since we consider a packet only lost after its deadline expires.

Due to the same reason, when applying a control decision to the erasure coding function, the effect on the control inputs is delayed by up to $D_T$. As a result, we will split the controller into two decoupled parts: first, the observability function, which periodically tracks and updates the estimated packet loss rates from the receiver, and second, the control function, which operates at a slower rate of $2\cdot RTT$ and computes the feed-forward term from the estimated packet loss in the upcoming erasure coding configuration search. It is important that the execution of the control function is triggered relative to some measure of $RTT$, or even $D_T$, since we should wait for the effects of a configuration change to become observable before triggering the control function anew.

The controller adaptively converges $P_{E2E}$ towards $P_T$ by applying a force to the estimated local packet loss rate $P_E$. The $P_E$ is our estimate of the channel’s current true packet loss rate, which must remain actionable across multiple magnitudes in packet loss rate and over the lifetime of the flow. Given a constant source packet interval $T_s$, lower packet loss rates naturally require much longer sampling periods. We track $P_E$ using a first-order infinite impulse response (IIR) filter $P_E[n]=P_E[n-1]+{\alpha }_n(P_I[n]-P_E[n-1])$ with adaptive smoothing coefficient ${\alpha }_n=P_E[n-1]$, and apply corrections for sample frequency and sample mass mismatch. $P_E$ acts as the model-estimated feed-forward term for our controller.

To continuously satisfy the target packet loss rate constraint $P_T$, the control function must adjust $P_E$ to compensate for the accumulated error due to unmodelled channel dynamics and forward the adjusted probability to the coding configuration search. To address this, we use an integral (I) error term based on packet deviation – packet debt – in our controller. We define packet debt as the number of packet we miss to reach the target packet loss rate $P_T$ at control step $i$ with $D_I[i]=N_{\text{SP}}[i]\cdot (P_{E2E}[i]-P_T)$, where $N_{SP}[i]$ is the total number of source packets sent up to control step $i$, and $P_{E2E}[i]$ the global end-to-end packet loss rate at step $i$. We refer to $D_I[i]$ as an integral term in relation to PID control, as it represents the accumulated error in the packet loss rate across all previously transmitted packets up to step $i$. Unlike an error rate, the packet debt remains a consistent physical measure across the lifetime of the flow. This directly addresses the model-mismatch problem, since packet debt will increase when non-IID channel dynamics undermine the effectiveness of our IID erasure-coding configurations.

Furthermore, we complement the packet debt (I) with its packet-debt integral (II) term, $D_{II}[i]={\sum }_{j=0}^{i}D[j]$, which will, over time, absorb the persistent bias of the channel model. By isolating the steady-state error over time, we allow the packet debt (I) itself to converge towards zero. Besides improving convergence, this reduces the load on the packet debt term and effectively increases its margin for responding to transient events.

We apply the total packet debt $D_I[i]$ at step $i$, and its accumulation $D_{II}[i]$ to the feed-forward local packet loss rate $P_E$ in the logit (log-odds) domain. This allows us to perform meaningful adjustments across the entire probability space, as additive corrections in the logit domain correspond to proportional shifts in odds, which remain consistent at the probability extremes. The final compensated packet loss rate is defined as:

where $\sigma (x)={(1+e^{-x})}^{-1}$ is the sigmoid function, and $K_I,K_{II}$ the gain for the correction logits. The debt force provides a strong, fast response, while the bias force is much slower and weaker to minimize oscillations. We define $K_I$ dynamically based on the current $P_E$ as $K_I=F_{I,max}\cdot P_T/(S_0\cdot P_E)$: if our estimated channel loss is low, we increase the gain, since packet losses are much rarer, which increases responsiveness to degrading channel conditions. On the other hand, when the packet loss rate is high, packet debt accumulates more quickly, justifying a smaller gain. The gain for the double integral $K_{II}$ is constant. Both compensation terms are clamped to their respective finite logit ranges. Additionally, we bound $D_{II}$ to prevent integrator windup.

The resulting compensated packet loss rate $P_{comp}$ is then forwarded to the coding configuration search, which, given the current channel, platform, and application constraints, translates it into a valid coding configuration.

The FEC subroutine assumes that the available time budget does not allow for ARQ cycles. This assumption allows us to simplify the repair packet schedule $N_P$ to contain only proactive redundancy $N_P=[N_P[0]]$. To find the valid coding parameters ($k$, $n$) that use minimal RI, we walk along the Pareto boundary defined by the effective packet loss rate (Eq. 1) and effective redundancy information (Eq. 2). The initial step finds the first valid coding configuration $(k,n)$, where either $k=1$ or $(n-k)=1$. The first step is guaranteed to find a valid coding configuration if the search space has a solution, since it minimizes the coding complexity constraint $C_{kp}$ and contains the extremes: no redundancy required $(k,n)=(1,1)$, maximum redundancy required $(k,n)=(1,n_{max})$, and minimum redundancy required $(k,n)=(\text{min}(n_{max}-1,k_{max}),1+\text{min}(n_{max}-1,k_{max}))$. We can define $k_{max}$ as

which is limited by the interaction between the delay constraint and the application source interval.²²2We subtract 1, since we assume at least one parity packet to exist. Otherwise, no redundancy is needed, and we can use $(k=1,n=1)$. If we cannot find a configuration that satisfies the loss and delay constraints, then no such configuration exists, and the search returns this outcome.

Given the initial valid configuration $(k_{opt},n_{opt})$, we can compute its effective redundancy information as $R{I}_{FEC}=\frac{n_{opt}}{k_{opt}}$ (Eq. 2 without ARQ). Any improvement to the RI must satisfy the ratio . Assuming , we can increment $n_{opt}$ to $n_{new}=n_{opt}+1$ and find the $k_{new}$ that satisfies , which results in jumping to $k_{new}>k_{opt}(1+\frac{1}{n_{opt}})$. After the RI-motivated jump, we perform a linear scan downwards from $k_{new}$ to find the largest $k$ that satisfies the search constraints, and use that as our new optimal coding configuration. Once the search space is exhausted, the search returns the optimal $(k,n)$, under the FEC-specific search constraints. The case for $n_{opt}-k_{opt}\ge k_{opt}$ works analogously by incrementing $k_{opt}$ and finding the corresponding $n_{new}-k_{new}$.

Extending the search to ARQ increases search complexity by accounting for the number of repair packet cycles $N_C$ and their contents. ARQ is essential for reducing the effective redundancy information, as argued in Section 2.2. The number of available cycles is largely determined by the interaction between the channel $RTT$ and the application delay constraint.

The nature of time-sensitive, real-world, hard-deadline constrained applications indicates a strong bias towards fewer cycles. Thus, to prevent search-space explosion, we limit the number of available ARQ cycles to $N_{C,lim}$, which results in $N_P[0]$ as the proactive FEC cycle and $N_P[1]$ to $N_P[N_{C,lim}]$ reactive ARQ cycles. This ARQ cycle limit defaults to $N_{C,lim}=5$. We define the maximum number of possible ARQ cycles as

where $D_{FEC,min}=\frac{RTT+D_{RS}}{2}+D_{PL}$ represents the delay of the trivial coding configuration $(k,n,N_P)=(1,1,[0])$, and $D_{ARQ}{[0]}_{min}=RTT+D_{RS}$ represents the delay that a single ARQ cycle introduces, where $D_{RS}$ is the response delay, and $D_{PL}$ the packet loss detection delay.

Introducing a cycle limit significantly reduces the number of possible repair packet schedules $N_P$, without losing the ability to tune the exponential RI gain within the available cycles. The effective redundancy information for ARQ coding configurations depends on the repair packet schedule $N_P$ as defined in Equation 2, which we can no longer use to “jump“ along the Pareto boundary. We instead follow it in incremental steps. Given the initial valid coding configuration described in the FEC section, we can compute its optimal schedule $N_P$ and its effective RI. Since $(k,n,N_P)$ satisfies the constraints, we can increment $k$ to try reducing the RI. When the target packet loss rate constraint is not satisfied, we increase $n$ and insert a new parity packet into $N_P$ at the position that minimizes the RI increase. The algorithm ends after at most $n_{max}$ steps. Each step involves a greedy search with complexity $O(k\cdot N_C^2)$ due to the effective RI calculation, which sums the failure-probability tail. This results in a total complexity of the search of $O(n\cdot k\cdot N_C^2)$, or roughly $O(n^2)$ with $k\le n\le 255$, and assuming $N_C$ as a small constant $N_C\le 5$ in practice. We evaluate the runtime behaviour of the incremental search in Section 6.3 (Figure 5).

First, we evaluate whether the reference implementation converges under a static IID channel-loss model. We configure the channel $RTT=20ms$, and use a true channel erasure (packet loss) rate of $P_e={10}^{-3}$, which equates to one loss every one thousand packets. We configure the application target delay to $D_T=100ms$, a target erasure rate $P_T={10}^{-5}$, and send one packet every $T_s=20\mu s$ microseconds ($50000$ packets per second) using thread spinning to ensure a constant source rate. In total, we send $6$ million packets, resulting in a flow duration of $2$ minutes.

Figure 3 shows the evolution of the end-to-end erasure rate $P_{E2E}$ observed by the controller, as well as the local channel erasure rate $P_E$, the compensated erasure rate $P_{comp}$, and the packet debt over time. The channel erasure rate $P_E$ in the plot represents the currently observed channel packet loss rate. It is initialized one magnitude above the target erasure rate $P_T$, which in this example is an underestimation, causing the initial HARQ coding configuration to be insufficient. As a result, once the first $P_{E2E}$ measurements of the receiver arrive, the controller computes a positive packet debt. This positive debt directly impacts the corrected erasure rate $P_{comp}$, causing it to spike to stabilize the packet debt. After four seconds, the observability function converges to the true channel erasure rate $P_e$, we see the packet debt decrease, and $P_{comp}$ converges towards $P_E$. For the remainder of the flow, we see that individual packet losses cause $P_{comp}$ to continue oscillating around $P_E$, reacting aggressively to each packet loss. Overall, the end-to-end erasure rate $P_{E2E}$ converges to the target erasure rate $P_T$, while the flow remains responsive to small changes in packet debt.

Second, we evaluate how the reference implementation responds to a dynamic channel and to non-IID channel dynamics. We configure the channel round-trip time to a static $RTT=20ms$. Next, we observe four phases of packet loss rate. The first phase acts as a stabilisation baseline with a packet loss rate of $0.01$ over a static IID channel. The second phase represents a sudden distribution shift that degrades the channel to a packet loss rate of $0.05$. The third phase uses a non-IID Simplified Gilbert-Elliott (SGE) channel model with a packet loss rate of $0.01$ and a strong correlation of $\rho =0.7$. The fourth phase repeats the baseline and removes the correlation of the third phase. We configure the application target delay to $D_T=100ms$, with a target erasure rate $P_T={10}^{-3}$, and send one packet every $T_s=20\mu s$ ($50000$ packets per second) using thread spinning to ensure a constant source rate. Every phase lasts for $400000$ packets, except the third model-mismatch phase, which lasts for $800000$ packets, thus a total of $2$ million packets. The higher packet loss rate makes the channel more responsive, helping us better visualize the controller’s long-term behaviour.

Figure 4-A shows the evolution of the end-to-end erasure rate $P_{E2E}$ observed by the controller, as well as the local channel erasure rate $P_E$, the corrected erasure rate $P_{comp}$, and the packet debt over time. Compared to the previous scenario, the initial guess for the channel packet loss rate, set to one (Odds-) magnitude above the target erasure rate $P_T$, is accurate, resulting in a much smoother start. Due to the higher packet loss rate, we can see how the packet debt varies significantly more and is also significantly larger. This showcases the effectiveness of the dynamic gain of the debt term. When the packet loss rate is high, we apply a weaker force per observed packet debt. We see one of these spikes at the beginning of the second phase, where the loss rate spikes from $0.01$ to $0.05$. Note that the channel observation function reacts to this change first, and slightly later the packet debt increases, due to its delay by roughly one target delay $D_T$. This makes the controller highly responsive at higher packet loss rates, since the local channel erasure rate $P_E$ adapts more quickly.

The third phase shows how the controller reacts to a non-IID SGE model with correlation $\rho =0.7$. The packet debt now exhibits increased volatility, with large packet-loss spikes and long periods where the debt steadily decreases. At the same time, the controller observes a more variable, yet still accurate, average channel erasure rate $P_E$ around the true erasure rate $P_e$. We can clearly see the gap between $P_E$ and $P_{comp}$, which compensates for the channel mismatch, and keeps the end-to-end erasure rate $P_{E2E}$ close to the target packet loss rate, effectively preventing it from diverging.

Figure 4-B shows the effective redundancy on the channel. While phases 1, 2, and 4 without correlation behave as expected, we can clearly see that in phase 3, the true local RI deviates significantly from the controller’s expected redundancy information. The controller computes the expected RI using $P_{comp}$, which Figure 4-A confirms to be consistently higher than $P_E$ during this mismatch phase. However, the true local RI, which is measured by counting the actual number of packets on the wire, remains close to $P_e$. This is in part due to the efficiency of ARQ. In this scenario, the strong correlation of the SGE channel introduces bursty packet losses, leading to longer continuous lossless or lossy transmission periods than in an IID channel. To correct these localized erasure patterns, we must use a higher code rate. However, this is balanced by ARQ, which transmits redundancy reactively when needed, causing little overhead during loss-free periods. This causes the true local RI to closely follow the evolution of the true average channel erasure rate $P_e$, and thus close to the channel capacity, although with clearly visible variability.

Third, we evaluate the controller’s incremental search execution time and RI efficiency across a range of common network parameters (Table 1), which covers a wide range of real-world network deployments. We generate a random search input sample by randomly selecting one magnitude per parameter of Table 1, and multiplying it with a floating point number . Finally, we set the response delay $D_{RS}=4\cdot D_{Polling}=200\mu s$, which defines how long the receiver takes to respond with a feedback packet, receive delay $D_{RCV}=4\cdot D_{Polling}=200\mu s$, which approximates the time a packet takes to travel from receiver thread to application, packet loss detection delay $D_{PL}=0.2\cdot RTT$, which defines how long we wait for the subsequent ARQ cycles to trigger, and $R_C=inf$ Mbps, which assumes the channel to not rate-limit. We consider a random search input valid if a coding configuration exists that satisfies the application constraints.

Table 2 shows the difference between the incremental search, which relies on a greedy, incremental schedule construction, and a non-greedy, full-search-like variant that rebuilds the schedule from scratch every step. Every datapoint was generated from $2.5$ million random valid configurations sampled from Table 1, and shows the total average RI difference between the greedy vs non-greedy variant. Since we only compare the effect of replacing a non-greedy schedule construction with the introduced greedy incremental search, the FEC case ($\mathrm{\Delta }{\text{RI}}_{0,0}$) matches exactly. In all other compared cases ($\mathrm{\Delta }{\text{RI}}_{N_{C,lim},N_{C,lim}}$), the RI difference is minimal. When we instead compare the incremental search to its non-greedy search with an additional cycle in $\mathrm{\Delta }{\text{RI}}_{N_{C,lim},N_{C,lim}+1}$, we observe a much larger RI difference, favouring the extended cycle limit. Moreover, we observe that this difference decreases as the cycle count increases. For example, incrementing the cycle limit from $2$ to $3$ yields a 5.3e-2 RI improvement averaged across the entire dataset, while incrementing the cycle limit from $5$ to $6$ only improves the total average RI by roughly 9.5e-3. This confirms that increasing the cycle limit eventually results in marginal gains. The default cycle limit of $N_{C,lim}=5$ provides a good balance between limiting the search space and providing RI-efficient coding configurations.

Figure 5 shows the execution time cumulative distribution function (CDF) of the incremental search with fixed coding complexity $\text{max\_kp}=2048$ constraint, and different cycle limits $\text{NC\_LIMIT}=\{0,5,9\}$, from pure FEC, to the default limit and an extended limit. The coloured vertical lines in the plot indicate the $99.9$th percentile for each NC_LIMIT configuration. The blue line represents the CDF of the execution time of the FEC subroutine. We clearly observe a disconnected group, indicating that the search returned the trivial solution: the channel is sufficiently good to satisfy the target packet-loss-rate constraint without coding. Additionally, the FEC subroutine is significantly faster than the ARQ subroutines, as indicated by the upper $50\%$ of slower execution times. The $99.9$th percentile for the FEC subroutine is $41.3$us, while the maximum cycle limit of $5$ takes $155\mu s$, and $9$ takes $187\mu s$. Overall, on a desktop computer, the search takes a fraction of the typical RTT, making it fast enough. Because of its anytime nature, we can introduce a hard search-time limit after the initial incremental search step, yielding predictable worst-case execution times. However, doing so will result in configurations that perform suboptimally in RI efficiency, causing computationally bound devices to spend more time coding. Hence, for computationally constrained devices, it is more effective to aggressively lower max_kp, as this bounds both the coding configuration search space and the coding complexity.

The evaluations confirm that the new reference implementation’s control loop converges the end-to-end packet loss rate $P_{E2E}$ towards the target packet loss rate $P_T$, even under model mismatch, and shows how both the packet debt and packet debt integral impact the corrected packet loss rate $P_{comp}$. Additionally, the incremental search performs near optimal compared to its non-greedy alternative, and fast enough to stay below common RTT values to support a real-time adaptive erasure coding scheme.

Recent machine learning approaches for real-time communication protocols show promising results by directly predicting channel parameters, such as FEC code rates, or more multimedia-specific statistics, such as packet prioritization. While these schemes work reasonably well in practice, they themselves act as black boxes due to their deep neural network architectures. This makes them challenging to use for safety-critical systems [25], which prefer interpretable components that benefit from more robust system integration. Furthermore, PRRT shows that extending proactive FEC with reactive ARQ can significantly improve RI efficiency, although it requires traversing a significantly more complex, discrete coding configuration space than pure FEC. Due to this complexity, directly predicting near-optimal HARQ-coding configurations is brittle and costly, requiring larger neural networks and search-space regularization [14].

To address these concerns and remain real-time viable, PRRT prioritizes using efficient, deterministic core algorithms built on existing domain knowledge to find predictable, and reliable solutions (incremental search). However, deterministic algorithms often rely on unrealistic assumptions to remain efficient, thereby underfitting the complexity of real-world dynamics. Similar to how feedback control scheduling uses miss ratios to compensate for unpredictable execution times due to hardware complexities like caching and branching [26], PRRT bridges this gap with a control loop that compensates for loss-model mismatch by using packet debt as the central metric.

To better understand the behaviour of this control loop, we turn to the concept of controllability. Control theory defines controllability in terms of a system’s ability to reach desired states (e.g., $P_T$) via its inputs (e.g., $P_{E2E}$). This poses a challenge in our case due to the complex nature of real-world networks, leaving us with a black box to work with. As a result, we cannot define controllability in the general sense here and instead defer to the application to specify the bounds the protocol must respect during operation. If PRRT finds a channel uncontrollable, we defer quality of service adjustments to the application, mirroring how elastic task models [2] and adaptive bitrate streaming [41, 44] operate. In this work, we require only that the measured end-to-end packet loss rate converge to the target packet loss rate, which is sufficient to show controllability in a broad sense. We defer to future work to build more formal models of convergence quality.

Overall, combining the mathematically reliable incremental search with a dynamic stability mechanism in the control loop offers a principled solution to provide predictably reliable, timely, and RI-efficient packet transport.

The key insight in designing efficient search algorithms for the HARQ coding configuration search is to restrict the search space. Previous work [32] favours a hybrid deep learning approach that predicts the parameter $k$ using a time-predictable deep neural network, followed by an optimized deterministic algorithm to derive the final valid coding configuration. While this approach works in practice, it hides much of the complexity within the neural network black box and comes with several downsides. For example, to achieve fast inference times, the network is trained on a smoothed dataset that accepts any good $k$, which results in coding configurations with suboptimal RI efficiency. Consequently, the search objective is no longer to find the optimal $k$, which changes the search complexity not just for the neural network, but also for its deterministic counterparts.

The incremental search leans into this relaxed, near-optimal objective and introduces coding complexity as an orthogonal optimization objective to the RI-efficiency. For now, the incremental search implements this as a hard limit with the max_kp parameter, although we can co-optimize the objectives to provide a more explicit balance between energy and RI-efficiency. Pereira [32] confirms that in many cases, there are numerous coding configurations that are within a few percentage points of the lowest achievable RI, which the incremental search is designed to traverse efficiently. Instead of searching for the optimal configuration directly or exhaustively, the incremental search quickly finds a valid configuration and then greedily improves it, incrementally increasing the allowed coding complexity at each step. Furthermore, compared to the black-box neural network that predicts any of the valid $k$ candidates, the incremental search can use a heuristic to bias, or restrict the available $k$ to ones that result in coding configurations that are efficient to encode and decode with the max_kp parameter. This has significant impacts on the efficiency and viability of PRRT for resource-constrained devices and provides a mechanism to properly pace the flow when encoding or decoding bottlenecks occur. Additionally, the incremental search is designed as an anytime algorithm [46]; the first step will always find a valid configuration if one exists, allowing us to interrupt the algorithm at any time after this first step to obtain a predictable worst-case execution time, similar to what neural networks offer. That said, this has limited use for the PRRT reference implementation, which optimizes its coding configuration at roughly $2\cdot RTT$, orders of magnitude slower than a single search execution.

The controller architecture enables us to design and formalise the convergence behaviour. For example, simple convergence, such as demonstrated by this paper, leads to oscillations around the target packet loss rate. The quality of convergence concerns itself with such oscillations, how to reduce them, and how to safely approach the target packet loss rate from below. Furthermore, we can consider satisfying the target packet loss rate over shorter time, or sample windows. This would require us to modify our original convergence objective to bias towards, e.g., controlling packet-loss spikes. Generally speaking, stricter requirements will incur some level of redundancy overprovisioning, reflecting the inherent cost of stronger piecewise reliability guarantees.

Finally, PRRT must implement a measure to prevent congestion collapse [22, 30]. Compared with elastic transport-layer protocols such as TCP, PRRT’s response to congestion is more nuanced, as it is designed to continuously satisfy its application constraints. This uniquely limits our ability to reduce PRRT’s data rate, as doing so would violate these application constraints. Instead, we plan to implement a function to estimate the value or efficiency of redundancy packets during protocol operation. If this value becomes negative or very small, we can reduce the number of parity packets, as they degrade the channel more than they benefit our erasure coding function. This approach is based on PRRT’s active role in the channel, which satisfies a precondition for active inference and causal discovery.