BAR: Blockwise Adaptive Recoding for Batched Network Coding ^†

Abstract

Multi-hop networks have become popular network topologies in various emerging Internet of Things (IoT) applications. Batched network coding (BNC) is a solution to reliable communications in such networks with packet loss. By grouping packets into small batches and restricting recoding to the packets belonging to the same batch; BNC has much smaller computational and storage requirements at intermediate nodes compared with direct application of random linear network coding. In this paper, we discuss a practical recoding scheme called blockwise adaptive recoding (BAR) which learns the latest channel knowledge from short observations so that BAR can adapt to fluctuations in channel conditions. Due to the low computational power of remote IoT devices, we focus on investigating practical concerns such as how to implement efficient BAR algorithms. We also design and investigate feedback schemes for BAR under imperfect feedback systems. Our numerical evaluations show that BAR has significant throughput gain for small batch sizes compared with existing baseline recoding schemes. More importantly, this gain is insensitive to inaccurate channel knowledge. This encouraging result suggests that BAR is suitable to be used in practice as the exact channel model and its parameters could be unknown and subject to changes from time to time.

1. Introduction

Noise, interference and congestion are common causes of packet loss in network communications. Usually, a packet has to travel through multiple hops before it can arrive at the destination node. Traditionally, the intermediate nodes apply the store-and-forward strategy. In order to maintain a reliable communication, retransmission is a common practice. A feedback mechanism is applied so that a network node can acknowledge that a packet is lost. However, due to the delay and bandwidth consumption of the feedback packets, retransmission schemes come with a cost of degraded system performance.

In the era of the Internet of things (IoT), there is a diversity of devices and network topologies. Embedded devices or microcomputers have been heavily deployed due to their mobility, lightweight design, and low power consumption. Multi-hop wireless networks have become a common network topology, highlighting the issues in reliable transmission as wireless links are more vulnerable to packet loss. The packet loss at each link accumulates and the chance of successfully receiving a packet at the destination drops exponentially. Fountain codes, such as in [1,2,3], can recover the lost packets without the need for feedback because of their ratelessness property. However, the throughput still degrades quickly if there is packet loss at each network link unless link-by-link feedback and retransmission are adopted.

1.1. Network Coding-Based Approaches

Random linear network coding (RLNC) [4,5], a simple realization of network coding [6,7,8], can achieve the capacity of multi-hop networks with packet loss even without the need for feedback [9,10]. Unfortunately, a direct application of RLNC induces an enormous overhead for the coefficient vectors, as well as high computational and storage costs in network coding operations at intermediate nodes, where the intermediate nodes are usually routers or embedded devices with low computational power and storage space.

Generation-based RLNC was proposed in [11] to resolve these issues. The input packets of the file are partitioned into multiple subsets called the generations, and RLNC is applied to each generation independently. This approach, however, cannot achieve an optimal theoretical rate. Practical concerns and solutions have been further investigated to improve this type of RLNC, such as decoding delay and complexity [12,13,14,15,16,17,18,19,20], packet size [21,22,23,24,25], and coefficient overhead [26,27,28].

Instead of partitioning into disjoint subsets, overlapped subsets were investigated in [29,30,31,32]. To further reduce the computational costs, the use of RLNC was restricted to small subsets of coded packets generated from the input packets in [33,34,35,36,37,38]. Example codes used for generating the coded packets include LDPC and fountain codes. This combination of coding theory and network coding is another variant of RLNC called batched network coding (BNC). BATS codes [38,39], a class of BNC, have a close-to-optimal achievable rate where the achievable rate is upper bounded by the expectation of the rank distribution of the batch transfer matrices that model the end-to-end network operations (packet erasures, network coding operations, etc.) on the batches [40]. This hints that the network coding operations, also known as recoding, have an impact on the throughput of BNC.

1.2. Challenges of Recoding in Practice

Baseline recoding is the simplest recoding scheme which generates the same number of recoded packets for every batch. Due to its simple and deterministic structure, baseline recoding appears in many BNC designs and analyses, such as [41,42,43,44,45,46]. However, the throughput of baseline recoding is not optimal with finite batch sizes [47]. The idea of adaptive recoding, aiming to outperform baseline recoding by generating different numbers of recoded packets for different batches, was proposed in [47] without truly optimizing the numbers. Two adaptive recoding optimization models for independent packet loss channels were then formulated independently in [48,49]. A unified adaptive recoding framework was proposed in [50], subsuming both optimization models and supporting other channel models under certain conditions.

Although adaptive recoding can be applied distributively with local network information, it is a challenge to obtain accurate local information when deploying adaptive recoding in real-world scenarios. Adaptive recoding requires two pieces of information: information distribution remaining in the received batches and the channel condition of the outgoing link.

The first piece of information may change over time if the channel condition of the incoming link varies. One reason for the variation is that the link quality can be affected by interference from users of other networks around the network node. We proposed a simple way to adapt to this variation in [49], grouping a few batches into a block and observing the distribution of received batches in this block. This approach was later called blockwise adaptive recoding (BAR) in [51,52].

The second piece of information may also vary from time to time. In some scenarios, such as deep-space [53,54,55] and underwater communications [56,57,58], feedback can be expensive or is not available; therefore, a feedbackless network is preferred. Without feedback, we cannot update our knowledge on the channel condition of the outgoing link. Although we may assume an unchanged channel condition and measure information such as the packet loss rate of the channel beforehand, this measurement, however, can be inaccurate due to observational errors or precision limits.

1.3. Contributions

In this paper, we focus on the practical design of applying BAR in real-world applications. Specifically, we answer the following questions in this paper:

• How does the block size affect the throughput?
• Is BAR sensitive to an inaccurate channel condition?
• How can one calculate the components of BAR and solve the optimization efficiently?
• How can one make use of link-by-link feedback if it is available?

The first question is related to the trade-off between throughput and latency: a larger block induces a longer delay but gives a higher throughput. We show by numerical evaluations that a small block size can already give a significant throughput gain compared with baseline recoding.

For the second question, we demonstrate that BAR performs very well with an independent packet loss model on channels with dependent packet loss. We also show that BAR is insensitive to an inaccurate packet loss rate. This is an encouraging result as this suggests that it is feasible to apply BAR in real-world applications.

The third question is important in practice as BAR is suppose to run at network nodes, usually routers or IoT devices with limited computational power, but also they may need to handle a huge amount of network traffic. Furthermore, by updating the knowledge of the incoming link from a short observation, we need to recalculate the components of BAR and solve the optimization problem again. In light of this, we want to reduce the number of computations to improve the reaction time and reduce the stress of congestion. We answer this question by proposing an on-demand dynamic programming approach to build the components and some implementation techniques to speed up the algorithm for BAR.

Lastly, for the fourth question, we consider both a perfect feedback system (e.g., the feedback passes through a side-channel with no packet loss) and a lossy feedback system (e.g., the feedback uses the reverse direction of the lossy channel for data transmission). We investigate a few ways to estimate the packet loss rate and show that the throughput can be further boosted by using feedback. Furthermore, a rough estimation is sufficient to catch up the variation in the channel condition. In other words, unless there is another application which requires a more accurate estimation on the packet loss rate, we may consider using an estimation with low computational cost, e.g., the maximum likelihood estimator.

1.4. Paper Organization and Nomenclature

The paper is organized as follows. We first formulate BAR in Section 2. Then, we discuss the implementation techniques for solving BAR efficiently and evaluate the throughput of different block sizes in Section 3. In Section 4, we demonstrate that BAR is insensitive to inaccurate channel models and investigate the use of feedback mechanisms. Lastly, we conclude the paper in Section 5.

Some specific terminology and notations appear frequently throughout the paper. We summarize some of the important terminology and frequently used notations in

Table 1. Terminology used for batched network coding (BNC).

Terminology	Description
Batch	A small set of coded packets.
Batch size	The number of coded packets in a batch.
Rank of a batch	A measure of “useful” information (linearly independent packets) retained in the batch.
Expected rank of a batch	The expectation of the rank of the batch at the next network node.
Incoming rank distribution	The distribution of the ranks of the batches arriving at the current network node.
Throughput	The expectation of the rank distribution of the batches arriving at the destination node.
Recoding	The network coding operations restricted to the packets belonging to the same batch.
Recoded packets	The coded packets generated by recoding.
Recoder	The module that performs recoding.
Baseline recoding	A strategy that generates the same number of recoded packets per batch.
Adaptive recoding	A strategy that generates different number of recoded packets per batch.
Block	A set of batches.
Blockwise adaptive recoding	Applying adaptive recoding block by block.

and

Table 2. Frequently used notations in this paper.

Notation	Description
M	Batch size.
$r_b$	The rank of the batch b.
$t_b$	The number of recoded packets for batch b.
$E(r_b,t_b)$	The expected rank of batch b when its rank is $r_b$ at the current node and $t_b$ recoded packets are sent.
$(h_0,\dots ,h_M)$	The incoming rank distribution.
p	The packet loss rate in the independent packet loss model.
$\mathcal{L}$	A block.
$t_{\max }^{\mathcal{L}}$	The total number of recoded packets in block $\mathcal{L}$.
$t_{\max }^b$	The maximum number of recoded packets allowed for batch b.
$\mathsf{Binom}(n,p)$	The binomial distribution.
$B_p(t,i)$	The probability mass function of the binomial distribution $\mathsf{Binom}(t,1-p)$.
${\beta }_p(t,r)$	The sum of the first r probability masses of $\mathsf{Binom}(t,1-p)$.
$\mathsf{Beta}(a,b)$	The beta distribution.
$I_x(a,b)$	The regularized incomplete beta function.

, respectively.

2. Blockwise Adaptive Recoding

In this section, we briefly introduce BNC and then formulate BAR.

2.1. Network Model

As some intermediate nodes may be hardware-implemented routers or not easily reachable for an upgrade, it is not required to deploy a BNC recoder at every intermediate node. The nodes that do not deploy a recoder are transparent to the BNC network as no network coding operations are performed. In the following text, we only consider intermediate nodes that have deployed BNC recoders.

It is not practical to assume every intermediate node knows the information of the whole network; thus, a distributed scheme that only requires local information is desirable. For example, the statistics of the incoming batches, the channel condition of the outgoing link, etc. In a general network, there may be more than one possible outgoing link to reach the destination. We can assign one recoder or one management unit for each outgoing link at an intermediate node [59,60]. In this way, we need a constraint to limit the number of recoded packets of certain batches sent via the outgoing links. The details are discussed in Section 2.4. In other words, we consider each route from the source to the destination separately as a line network.

Line networks are the fundamental building blocks of a general network. Conversely, a recoding scheme for line networks can be extended to general unicast networks and certain multicast networks [38,48]. A line network is a sequence of network nodes where the network links only exist between two neighbouring nodes. An example of a line network is illustrated in Figure 1. In this paper, we only consider line networks in our numerical evaluations.

2.2. Batched Network Coding

Suppose we want to send a file from a source node to a destination node through a multi-hop network. The file is divided into multiple input packets, where each packet is regarded as a vector over a fixed finite field. A BNC has three main components: the encoder, the recoder and the decoder.

The encoder of a BNC is applied at the source node to generate batches from the input packets, where each batch consists of a small number of coded packets. Recently, a reinforcement learning approach to optimize the generation of batches was proposed in [61]. Nevertheless, batches are commonly generated using the traditional approach as follows. To generate a batch, the encoder samples a predefined degree distribution to obtain a degree, where the degree is the number of input packets that constitute the batch. Depending on the application, there are various ways to formulate the degree distribution [62,63,64,65]. According to the degree, a set of packets is chosen randomly from the input packets. The size of the input packets may be obtained via certain optimizations, such as in [66], to minimize the overhead. Each packet in the batch is formed by taking random linear combinations on the chosen set of packets. The encoder generates M packets per batch, where M is known as the batch size.

Each packet in a batch has a coefficient vector attached to it. Two packets in a batch are defined as linearly independent of each other if and only if their coefficient vectors are linearly independent from each other. Immediately after a batch is generated, the packets within it are assigned as linearly independent from each other. This is accomplished by suitably choosing the initial coefficient vectors [59,67].

A recoder is applied at each intermediate node, performing network coding operations on the received batches to generate recoded packets. This procedure is known as recoding. Some packets of a batch may be lost when they pass through a network link. Each recoded packet of a batch is formed by taking a random linear combination of the received packets in a given batch. The number of recoded packets depends on the recoding scheme. For example, baseline recoding generates the same number of recoded packets for every batch. Optionally, we can also apply a recoder at the source node so that we can have more than M packets per batch at the beginning. After recoding, the recoded packets are sent to the next network node.

At the destination node, a decoder is applied to recover the input packets. Depending on the specific BNC, we can use different decoding algorithms, such as Gaussian elimination, belief propagation and inactivation [68,69].

2.3. Expected Rank Functions

The rank of a batch at a network node is defined by the number of linearly independent packets remaining in the batch, a measure of the amount of information carried by the batch. Adaptive recoding aims to maximize the sum of the expected value of the rank distribution of each batch arriving at the next network node. For simplicity, we called this expected value the expected rank.

For batch b, we denote its rank by $r_b$ and the number of recoded packets to be generated by $t_b$. The expectation of $r_b$ at the next network node, denoted as $E(r_b,t_b)$, is known as the expected rank function. We have

$$E(r,t)=\sum _{i=0}^{t}Pr(X_t=i)\sum _{j=0}^{min\{i,r\}}j{\zeta }_j^{i,r},$$

(1)

where $X_t$ is the random variable of the number of packets of a batch received by the next network node when we send t packets for this batch at the current node, and ${\zeta }_j^{i,r}$ is the probability that a batch of rank r at the current node with i received packets at the next network node has rank j at the next network node. The exact formulation of ${\zeta }_j^{i,r}$ can be found in [38], which is ${\zeta }_j^{i,r}=\frac{{\zeta }_j^i{\zeta }_j^r}{{\zeta }_j^j{q}^{(i-j)(r-j)}}$, where q is the field size for the linear algebra operations and ${\zeta }_j^m={\prod }_{k=0}^{j-1}(1-q^{-m+k})$. It is convenient to use $q=2^8$ in practice as each symbol in this field can be represented by 1 byte. For a sufficiently large field size, say $q=2^8$, ${\zeta }_j^{i,r}$ is very close to 1 if $j=min\{i,r\}$, and is very close to 0 otherwise. That is, we can approximate ${\zeta }_j^{i,r}$ by ${\delta }_{j,min\{i,r\}}$ where ${\delta }_{·,·}$ is the Kronecker delta. This approximation has also been used in the literature, see, e.g., [45,70,71,72,73,74,75,76].

Besides generating all recoded packets by taking random linear combinations, systematic recoding [39,47,59,67], which concerns received packets as recoded packets, can be applied to save computational time. Systematic recoding can achieve a nearly indistinguishable performance compared with methods which generate all recoded packets by taking random linear combinations [39]. Therefore, we can also use (1) to approximate the expected rank functions for systematic recoding accurately.

For the independent packet loss model with packet loss rate p, we have $X_t\sim \mathsf{Binom}(t,1-p)$, a binomial distribution. If $p=1$, then a store-and-forward technique can guarantee the maximal expected rank. If $p=0$, then no matter how many packets we transmit, the next network node must receive no packets. Thus, we assume $0<p<1$ in this paper. It is easy to prove that the results in this paper are also valid for $p=0$ or 1 when we define $0^0:=1$, which is a convention in combinatorics such that $\mathsf{Binom}(t,0)$ and $\mathsf{Binom}(t,1)$ are well-defined with correct interpretation. In the remaining text, we assume ${\zeta }_j^{i,r}={\delta }_{j,min\{i,r\}}$. That is, for the independent packet loss model, we have

$$E_{\mathsf{indep}}(r,t)=\sum _{i=0}^t\left(\genfrac{}{}{0pt}{}{t}{i}\right){(1-p)}^i{p}^{t-i}min\{i,r\}.$$

(2)

A demonstration of the accuracy of the approximation ${\zeta }_j^{i,r}\approx {\delta }_{j,min\{i,r\}}$ can be found in Appendix A.

We also consider the expected rank functions for burst packet loss channels modelled by Gilbert–Elliott (GE) models [77,78], where the GE model was also used in other BNC literature such as [52,55,70]. A GE model is a two-state Markov chain, as illustrated in Figure 2. In each state, there is an independent event to decide whether a packet is lost or not. We define $f(s,i,t):=Pr(S_t=s,X_t=i)$, where $S_t$ is the random variable of the state of the GE model after sending t packets of a batch. By exploiting the structure of the GE model, computation of f can be performed by dynamic programming. Then, we have

$$E_{\mathsf{GE}}(r,t)=\sum _{i=0}^t(f(\mathbf{G},i,t)+f(\mathbf{B},i,t))min\{i,r\}.$$

(3)

It is easy to see that it would take more steps to compute (3) than (2). Therefore, a natural question to ask is that for burst packet loss channels, is the throughput gap small between adaptive recoding with (2) and (3)? We demonstrate in Section 4.2 that the gap is small so we use (2) any time a nice throughput is received. Therefore, in our investigation we mainly focus on (2).

In the rest of this paper, we refer to $E(r,t)$ as $E_{\mathsf{indep}}(r,t)$ unless otherwise specified. From [50], we know that when the loss pattern follows a stationary stochastic process, the expected rank function $E(r,t)$ is a non-negative, monotonically increasing concave function with respect to t, which is valid for arbitrary field sizes. Further, $E(r,0)=0$ for all r. However, we need to calculate the values of $E(r,t)$ or its supergradients to apply adaptive recoding in practice. To cope with this issue, we first investigate the recursive formula for $E(r,t)$.

We define the probability mass function of the binomial distribution $\mathsf{Binom}(t,1-p)$ by

$$B_p(t,i)=\left\{\begin{array}{cc}\left(\genfrac{}{}{0pt}{}{t}{i}\right){(1-p)}^i{p}^{t-i}\hfill & \mathrm{if}0\le i\le t,\hfill \\ 0\hfill & \mathrm{otherwise}.\hfill \end{array}\right.$$

(4)

For integers $r\ge 0$ and $t\ge -1$, we define

$${\beta }_p(t,r)=\left\{\begin{array}{cc}1\hfill & \mathrm{if}t\le r-1,\hfill \\ \sum _{i=0}^{r-1}\left(\genfrac{}{}{0pt}{}{t}{i}\right){(1-p)}^i{p}^{t-i}=\sum _{i=0}^{r-1}{B}_p(t,i)\hfill & \mathrm{otherwise}.\hfill \end{array}\right.$$

(5)

When $t\ge 0$, the function ${\beta }_p(t,r)$ is the partial sum of the probability masses of a binomial distribution $\mathsf{Binom}(t,1-p)$. The case where $t=-1$ is used in the approximation scheme in Section 3 and is discussed in that section.

The regularized incomplete beta function, defined as $I_x(a,b):=\frac{{\int }_0^x{t}^{a-1}{(1-t)}^{b-1}dt}{{\int }_0^1{t}^{a-1}{(1-t)}^{b-1}dt}$ ([79], Equation 8.17.2), can be used to express the partial sum of the probability masses of a binomial distribution. When $t\ge r>0$, we can apply ([79], Equation 8.17.5) and obtain

$${\beta }_p(t,r)=\sum _{i=0}^{r-1}\left(\genfrac{}{}{0pt}{}{t}{i}\right){(1-p)}^i{p}^{t-i}=I_p(t-r+1,r).$$

(6)

There are different implementations of $I_p(·,·)$ available for different languages. For example, the GNU Scientific Library [80] for C and C++, or the built-in function betainc in MATLAB. However, most available implementations consider non-negative real parameters and calculate different queries independently. This consideration is too general for our application, as we only need to query the integral points efficiently. In other words, this formula may be sufficient for prototyping or simulation, but it is not efficient enough for real-time deployment on devices with limited computational power. Nevertheless, this formula is useful for proving the following properties:

Lemma 1.

Assume $0<p<1$. Let Λ be an index set.

(a) 

${\displaystyle B_p(t+1,i)=(1-p)B_p(t,i-1)+p{B}_p(t,i)}$ for $i=0,1,\dots ,t$;

(b) 

${\displaystyle {\beta }_p(t+1,r)\le {\beta }_p(t,r)}$ where the equality holds if and only if $t+1<r$ or $t\ge r=0$;

(c) 

${\displaystyle {\beta }_p(t,r)\le {\beta }_p(t+1,r+1)}$ where the equality holds if and only if $t<r$;

(d) 

${\displaystyle {\beta }_p(t,r+1)\ge {\beta }_p(t,r)}$ where the equality holds if and only if $t<r$;

(e) 

${\displaystyle 1\ge \underset{b\in \mathrm{\Lambda }}{max}{\beta }_p(t_b,r_b)\ge {\beta }_p(t_a+s,r_a)}$ for all $a\in \mathrm{\Lambda }$ and any non-negative integer s;

(f) 

${\displaystyle 0\le \underset{b\in \mathrm{\Lambda }}{min}{\beta }_p(t_b,r_b)\le {\beta }_p(t_a-s,r_a)}$ for all $a\in \mathrm{\Lambda }$ and any non-negative integer s such that $t_a-s\ge -1$.

Proof. 

See Appendix B.    □

With the notation of ${\beta }_p(t,r)$, we can now write the recursive formula for $E(r,t)$.

Lemma 2.

$E(r,t+1)=E(r,t)+(1-p){\beta }_p(t,r)$, where t and r are non-negative integers.

Proof. 

Let $Y_i$ be independent and identically distributed Bernoulli random variables, where $Pr(Y_i=1)=1-p$ for all i. When $Y_i=1$, the i-th packet is received by the next hop.

When we transmit one more packet at the current node, $Y_{t+1}$ indicates whether this packet is received by the next network node or not. If $Y_{t+1}=0$, i.e., the packet is lost, then the expected rank will not change. If $Y_{t+1}=1$, then the packet is linearly independent from all the already received packets at the next network node if the number of received packets at the next network node is less than r. That is, the rank of this batch at the next network node increases by 1 if ${\sum }_{i=1}^t{Y}_i<r$. Therefore, the increment of $E(r,t)$ is $Pr(Y_{t+1}=1,{\sum }_{i=1}^t{Y}_i<r)$. Note that ${\sum }_{i=1}^t{Y}_i\sim \mathsf{Binom}(t,1-p)$. As $Y_i$ are all independent and identically distributed, we have $Pr\left(Y_{t+1}=1,{\sum }_{i=1}^t{Y}_i<r\right)=(1-p){\beta }_p(t,r)$.    □

The formula shown in Lemma 2 can be interpreted as a newly received packet that is linearly independent of all the already received packets with a probability tends to 1 unless the rank has already reached r. This can also be interpreted as ${\zeta }_j^{i,r}={\delta }_{j,min\{i,r\}}$ with a probability tends to 1. The above lemma can be rewritten in a more useful form as stated below.

Lemma 3.

Let t and r be non-negative integers.

(a) 

$E(r,t+1)=E(r,t)+(1-p)$ if $t<r$;

(b) 

$E(r,t)=(1-p){\sum }_{j=0}^{t-1}{\beta }_p(j,r)=(1-p)\left(min\{r,t\}+{\sum }_{j=r}^{t-1}{\beta }_p(j,r)\right)$.

Proof. 

See Appendix C.    □

2.4. Blockwise Adaptive Recoding

The idea of adaptive recoding was presented in [47], and then independently formulated in [48,49]. The former formulation imposes an artificial upper bound on the number of recoded packets and then applies a probabilistic approach to avoid integer programming. The latter investigates the properties of the integer programming problem and proposed efficient algorithms to directly tackle this problem. These two formulations were unified in [50] as a general recoding framework for BNC. This framework requires the distribution of the ranks of the incoming batches, also called the incoming rank distribution. This distribution, however, is not known in advance, and can continually change due to environmental factors. A rank distribution inference approach was proposed in [81], but the long solving time hinders its application in real-time scenarios.

A more direct way to obtain up-to-date statistics is to use the ranks of the few latest batches, a trade-off between a latency of a few batches and the throughput of the whole transmission. This approach was proposed in [49], and later called BAR in [51,52]. In other words, BAR is a recoding scheme which groups batches into blocks and jointly optimizes the number of recoded packets for each batch in the block.

We first describe the adaptive recoding framework and its relation to BAR. We fix an intermediate network node. Let $(h_0,h_1,\dots ,h_M)$ be the incoming rank distribution, $t_r$ the number of recoded packets to be sent for a batch of rank r, and $t_{\mathrm{avg}}$ the average number of recoded packets to be sent per batch. The value of $t_r$ is a non-negative real number that is interpreted as follows. Let $ϵ=t_r-\lfloor t_r\rfloor$ be the fractional part of $t_r$. There is an $ϵ$ chance to transmit $\lfloor t_r\rfloor +1$ recoded packets, and a $1-ϵ$ chance to transmit $\lfloor t_r\rfloor$ packets. That is, the fraction is the probability of transmitting one more packet. Similarly, $E(r,t_r)$ is defined as the linear interpolation by $(1-ϵ)E(r,\lfloor t_r\rfloor )+ϵE(r,\lfloor t_r\rfloor +1)$. The framework maximizes the expected rank of the batches at the next node, which is the optimization problem:

$$\underset{t_r\ge 0,\forall r\in \{0,1,\dots ,M\}}{max}\sum _{r=0}^M{h}_{r}E(r,t_r)\mathrm{s}.\mathrm{t}.\sum _{r=0}^M{h}_r{t}_r=t_{\mathrm{avg}}.$$

(7)

For BAR, the incoming rank distribution is obtained from the recently received few batches. Let a block be a set of batches. We assume that the blocks at a network node are mutually disjoint. Suppose the node receives a block $\mathcal{L}$. For each batch $b\in \mathcal{L}$, let $r_b$ and $t_b$ be the rank of b and the number of recoded packets to be generated for b, respectively. Let $t_{\max }^{\mathcal{L}}=t_{\mathrm{avg}}/\left|\mathcal{L}\right|$ be the number of recoded packets to be transmitted for the block $\mathcal{L}$. The batches of the same rank are considered individually with the notations $r_b$ and $t_b$, and the total number of packets to be transmitted for a block is finite; therefore, we assume $t_b$ for each $b\in \mathcal{L}$ is a non-negative integer, and $t_{\max }^{\mathcal{L}}$ is a positive integer. By dividing both the objective and the constraint of the framework by $\left|\mathcal{L}\right|$, we obtain the simplest formulation of BAR:

$$\underset{t_b\in \{0,1,2,\dots \},\forall b\in \mathcal{L}}{max}\sum _{b\in \mathcal{L}}E(r_b,t_b)\mathrm{s}.\mathrm{t}.\sum _{b\in \mathcal{L}}{t}_b=t_{\max }^{\mathcal{L}}.$$

(8)

To support scenarios with multiple outgoing links for the same batch, e.g., load balancing, we may impose an upper bound on the number of recoded packets per batch. Let $t_{\max }^b$ be a non-negative integer that represents the maximum number of recoded packets allowed to be transmitted for the batch b. This value may depend on the rank of b at the node. Subsequently, we can formulate the following optimization problem based on (8):

$$\begin{array}{ccc}\hfill {\displaystyle \underset{t_b\in \{0,1,2,\dots \},\forall b\in \mathcal{L}}{max}}& & {\displaystyle \sum _{b\in \mathcal{L}}}E(r_b,t_b)\hfill \\ \hfill \mathrm{s}.\mathrm{t}.& & {\displaystyle \sum _{b\in \mathcal{L}}}{t}_b=t_{\max }^{\mathcal{L}}\hfill \\ \hfill & & t_b\le t_{\max }^b,\forall b\in \mathcal{L}.\hfill \end{array}$$

(9)

Note that we must have ${\sum }_{b\in \mathcal{L}}{t}_{\max }^b\ge t_{\max }^{\mathcal{L}}$. In the case where this inequality does not hold, we can include more batches in the block to resolve this issue. When $t_{\max }^b$ is sufficiently large for all $b\in \mathcal{L}$, (9) degenerates into (8).

The above optimization only depends on the local knowledge at the node. The batch rank $r_b$ can be known from the coefficient vectors of the received packets of batch b. As a remark, the value of $t_{\max }^{\mathcal{L}}$ can affect the stability of the packet buffer. For a general network transmission scenario with multiple transmission sessions, the value of $t_{\max }^{\mathcal{L}}$ can be determined by optimizing the utility of certain local network transmissions [82,83].

Though we do not discuss such optimizations in this paper, we consider solving BAR with a general value of $t_{\max }^{\mathcal{L}}$.

On the other hand, note that the solution to (9) may not be unique. We only need to obtain one solution for recoding purpose. In general, (9) is a non-linear integer programming problem. A linear programming variant of (9) can be formulated by using a technique in [81]. However, such a formulation has a huge amount of constraints and requires the values of $E(r_b,t)$ for all $b\in \mathcal{L}$ and all possible t to be calculated beforehand. We defer the discussion of this formulation to Appendix H.

A network node will keep receiving packets until it has received enough batches to form a block $\mathcal{L}$. A packet buffer is used to store the received packets. Then, the node solves (9) to obtain the number of recoded packets for each batch in the block, i.e., ${\left\{t_b\right\}}_{b\in \mathcal{L}}$. The node then generates and transmits $t_b$-recoded packets for every batch $b\in \mathcal{L}$. At the same time, the network node continually receives new packets. After all the recoded packets for the block $\mathcal{L}$ are transmitted, the node drops the block from its packet buffer and then repeats the procedure by considering another block.

We do not specify the transmission order of the packets. Within the same block, the ordering of packets can be shuffled to combat burst loss, e.g., [43,44,52]. Such shuffling can reduce the burst error length experienced by each batch so that the packet loss events are more “independent” from each other. On the other hand, we do not specify the rate control mechanism, as it should be separated as another module in the system. This can be reflected in BAR by choosing suitable expected rank functions, e.g., modifying the parameters in the GE model. BAR is only responsible for deciding the number of recoded packets per batch.

The size of a block depends on its application. For example, if an interleaver is applied to L batches, we can group the L batches as a block. When $\left|\mathcal{L}\right|=1$, the only solution is $t_b=t_{\max }^{\mathcal{L}}$, which degenerates into baseline recoding. Therefore, we need to use a block size of at least 2 in order to utilize the throughput enhancement of BAR. Intuitively, it is better to optimize (9) with a larger block size. However, the block size is related to the transmission latency as well as the computational and storage burdens at the network nodes. Note that we cannot conclude the exact rank of each batch in a block until the previous network node finishes sending all the packets of this block. That is, we need to wait for the previous network node to send the packets of all the batches in a block until we can solve the optimization problem. Numerical evaluations in Section 3.5 show that $\left|\mathcal{L}\right|=2$ already has obvious advantage over $\left|\mathcal{L}\right|=1$, and it may not be necessary to use a block size larger than eight.

3. Implementation Techniques for Blockwise Adaptive Recoding

In this paper, we focus on the implementation and performance of BAR. Due to the non-linear integer programming structure of (9), we need to make use of certain properties of the model in order to solve it efficiently. The authors of [49] proposed greedy algorithms to solve (9), which were then generalized in [50] to solve (7). The greedy algorithms in [50] have an potential issue when certain probability masses in the incoming rank distribution are too small, as they may take too many iterations to find a feasible solution. The number of iterations is in the order of ${\sum }_{r=0}^M{t}_r$, depending on the solution to (7). That is, we cannot establish a bound on the time complexity as the incoming rank distribution can be arbitrary.

For BAR, we do not have this issue because the number of recoded packets in a block, $t_{\max }^{\mathcal{L}}$, is fixed.

In this section, we first discuss the greedy algorithm to solve (9) in Section 3.1. Then, we propose an approximation scheme in Section 3.2, and discuss its application to speed up the solver for practical implementations in Section 3.3. The algorithms in Section 3.1 and Section 3.3 are similar to that in [50], but they are modified to optimize BAR. Note that the algorithms in [50] are generalized from [49], so the correctness of the aforementioned modified algorithms is inherited directly from the generalized proofs in [50]. For the approximation scheme in Section 3.2, which did not appear in [50], a more detailed discussion is provided in this section.

The algorithms in this section frequently query and compare the values of $(1-p){\beta }_p(t,r)$ for different $t\in \{-1,0,1,\dots ,t_{\max }^{\mathcal{L}}\}$ and $r\in \{0,1,2,\dots ,M\}$. We suppose a lookup table is constructed so that the queries can be performed in $\mathcal{O}\left(1\right)$ time. The table is reusable if the packet loss rate of the outgoing link is unchanged. We only consider the subset $\{-1,0,1,\dots ,t_{\max }^{\mathcal{L}}\}\times \{0,1,2,\dots ,M\}$ of the ${\beta }_p$ domain because

• the maximum rank of a batch is M;
• any $t_b$ cannot exceed $t_{\max }^{\mathcal{L}}$ as ${\sum }_{b\in \mathcal{L}}{t}_b=t_{\max }^{\mathcal{L}}$.

The case $t=-1$ will be used by our approximation scheme so we keep it in the lookup table. We can build the table on-demand by dynamic programming, discussed in Section 3.4.

3.1. Greedy Algorithm

We first discuss the case $t_{\max }^{\mathcal{L}}\le {\sum }_{b\in \mathcal{L}}min\{r_b,t_{\max }^b\}$. This condition means that the value of $t_{\max }^{\mathcal{L}}$ is too small such that the node has just enough or even not enough time to forward the linearly independent packets received. It is trivial that every ${\left\{t_b\right\}}_{b\in \mathcal{L}}$ satisfying $0\le t_b\le min\{r_b,t_{\max }^b\}$ and ${\sum }_{b\in \mathcal{L}}{t}_b=t_{\max }^{\mathcal{L}}$ is a solution to (9), because every such recoded packet gains $1-p$ to the expected rank by Lemma 3(a),where this gain is maximal according to the definition of ${\beta }_p(t,r)$.

For $t_{\max }^{\mathcal{L}}>{\sum }_{b\in \mathcal{L}}min\{r_b,t_{\max }^b\}$, we can initialize $t_b$ by $min\{r_b,t_{\max }^b\}$ for every $b\in \mathcal{L}$ as every such recoded packet gains the maximal value $1-p$ to the expected rank. After this, the algorithm chooses the batch that can gain the most expected rank by sending one more recoded packet, and assigns one more recoded packet to it. The correctness is due to the concavity of the expected rank functions.

The above initialization reduces most iterations in the algorithm, as in practice, the difference between the number of recoded packets and the rank of the batch is not huge. Algorithm 1 is the improved greedy algorithm. Unlike the version in [50], the complexity of Algorithm 1 does not depend on the solution.

Algorithm 1: Solver for BAR.

Theorem 1.

Algorithm 1 can be ran in $\mathcal{O}\left(\right|\mathcal{L}|+max\{0,t_{\max }^{\mathcal{L}}-{\sum }_{b\in \mathcal{L}}min\{r_b,t_{\max }^b\}\}log|\mathcal{L}\left|\right)$ time.

Proof. 

There are totally $max\{0,t_{\max }^{\mathcal{L}}-{\sum }_{b\in \mathcal{L}}min\{r_b,t_{\max }^b\}\}$ iterations in the while loop. The query of $\mu ={arg\; max}_{b\in \mathcal{L}\setminus T}{\beta }_p(t_b,r_b)$ can be implemented by using a binary heap. The initialization of the heap, i.e., heapify, takes $\mathcal{O}\left(\right|\mathcal{L}\left|\right)$ time, which can be performed outside the loop. Each query in the loop takes $\mathcal{O}\left(1\right)$ time. The update from ${\beta }_p(t_{\mu },r_{\mu })$ into ${\beta }_p(t_{\mu }+1,r_{\mu })$, if $t_{\mu }<t_{\max }^{\mu }-1$, takes $\mathcal{O}(log|\mathcal{L}\left|\right)$ time. For $t_{\mu }=t_{\max }^{\mu }-1$, we may remove the entry from the heap, taking the same time complexity as the update above. As ${\sum }_{b\in \mathcal{L}}min\{r_b,t_{\max }^b\}\ge t_{\max }^{\mathcal{L}}$ by assumption, the algorithm will not query an empty heap. Therefore, the overall time complexity is $\mathcal{O}\left(\right|\mathcal{L}|+max\{0,t_{\max }^{\mathcal{L}}-{\sum }_{b\in \mathcal{L}}min\{r_b,t_{\max }^b\}\}log|\mathcal{L}\left|\right)$.    □

In the algorithm, we assume that a lookup table for ${\beta }_p(t,r)$ is pre-computed. The table can be reused unless there is an update on the outgoing channel condition. Nevertheless, we will discuss an efficient way to construct the lookup table in Section 3.4, and the insignificance of the measurement or prediction errors of the loss probability of the outgoing channel in Section 4.

As the query ${arg\; max}_{b\in \mathcal{L}\setminus T}{\beta }_p(t_b,r_b)$ is run repeatedly and an update is performed after every query, we can use a binary heap as described in the proof in real implementation. Note that by Lemma 1(b), ${\beta }_p(t_{\mu },r_{\mu })\ge {\beta }_p(t_{\mu }+1,r_{\mu })$, so the update is a decrease key operation in a max-heap. In other words, a Fibonacci heap [84] cannot benefit from this operation here.

3.2. Equal Opportunity Approximation Scheme

Algorithm 1 increases $t_b$ step by step. From a geometric perspective, the algorithm finds a path from the interior of a compact convex polytope that models the feasible solutions to the facet $\mathcal{H}:{\sum }_{b\in \mathcal{L}}{t}_b=t_{\max }^{\mathcal{L}}$. If we have a method to move a non-optimal feasible point on $\mathcal{H}$ towards an optimal point, together with a fast and accurate approximation to (8) or (9), then we can combine them to solve (9) faster than using Algorithm 1 directly. This idea is illustrated in Figure 3. A generalized tuning scheme can be found in [50] based on the algorithm in [49]. However, there is no approximation scheme proposed in [50].

We first give an approximation scheme in this subsection. The approximation is based on an observation of the solution for (8) that does not impose an upper boundary on $t_b$: A batch of higher rank should have more recoded packets transmitted than a batch of lower rank. Unless most $t_{\max }^b$ are too small, the approximation for (8) is also a good approximation for (9).

Theorem 2.

Let $\mathcal{L}$ be a block where $\left|\mathcal{L}\right|\ge 2$. If ${\left\{t_b\right\}}_{b\in \mathcal{L}}$ solves (8) and $t_b\ge r_b$ for all $b\in \mathcal{L}$, then $t_m<t_n$ for all $m,n\in \mathcal{L}$ such that $r_m<r_n$.

Proof. 

See Appendix D.    □

As we cannot generate any linearly independent packets for a batch of rank 0, we have $E(0,·)=0$. Therefore, we can exclude batches of rank 0 from $\mathcal{L}$ before we start the approximation. We define $\mathfrak{L}=\{b\in \mathcal{L}:r_b>0\}\subseteq \mathcal{L}$. When $t_{\max }^{\mathcal{L}}>{\sum }_{b\in \mathcal{L}}{r}_b$, we have $t_b\ge r_b$ for all $b\in \mathcal{L}$. An easy way to obtain an approximation is to assign ${\left\{t_b\right\}}_{b\in \mathcal{L}}$ following the guidelines given in Theorem 2 by:

• $t_b=0$ for all $b\in \mathcal{L}\backslash \mathfrak{L}$;
• $t_b=r_b+\ell$ for all $b\in \mathfrak{L}$.

where $\ell =(t_{\max }^{\mathcal{L}}-{\sum }_{b\in \mathcal{L}}{r}_b)/\left|\mathfrak{L}\right|$. In the case where ℓ is not an integer, we can round it up for batches with higher ranks and round it down for those with lower ranks.

The above rules allocate the unassigned packets to batches equally after $r_b$ packets have been assigned to each batch b. Thus, we call this approach the equal opportunity approximation scheme. The steps of this scheme are summarized in Algorithm 2.

Note that we do not need to know the packet loss rate p to apply this approximation. That is, if we do not know the value of p, we can still apply this approximation to outperform baseline recoding.

Theorem 3.

Algorithm 2 approximates (8) in $\mathcal{O}\left(\right|\mathcal{L}\left|\right)$ time. If $t_{\mathit{max}}^{\mathcal{L}}\le {\sum }_{b\in \mathcal{L}}{r}_b$, then the algorithm solves (8).

Algorithm 2: Equal opportunity approximation scheme.

Proof. 

It is easy to see that Algorithm 2 outputs ${\left\{t_b\right\}}_{b\in \mathcal{L}}$ which satisfies ${\sum }_{b\in \mathcal{L}}{t}_b=t_{\max }^{\mathcal{L}}$. That is, the output is a feasible solution of (8). Note that $\left|\mathfrak{L}\right|\le \left|\mathcal{L}\right|$, so the assignments and the branches before the last for loop take $\mathcal{O}\left(\right|\mathcal{L}\left|\right)$ time in total. The variable L after the first foreach loop equals $\left|\mathfrak{L}\right|$. Adding one to the number of recoded packets for $r=\ell modL$ batches with the highest ranks can be performed in $\mathcal{O}\left(\right|\mathcal{L}\left|\right)$ time. Therefore, the overall running time is $\mathcal{O}\left(\right|\mathcal{L}\left|\right)$.

If $\mathfrak{L}=\varnothing$, i.e., the whole block is lost, then any feasible ${\left\{t_b\right\}}_{b\in \mathcal{L}}$ is a solution, and the optimal objective value is 0. If $t_{\max }^{\mathcal{L}}\le {\sum }_{b\in \mathcal{L}}{r}_b$, then the algorithm terminates with an output satisfying $t_b\le r_b$ for all $b\in \mathcal{L}$, which is an optimal solution.    □

For the step that adds 1 to the number of recoded packets for $r=\ell modL$ batches with the highest ranks in the algorithm, the worst linear time case can be achieved by using introselect [85] (which is quickselect [86] with a random pivot, but changes to use the median of medians [87] pivot strategy when the complexity grows). We use the selection algorithm to find the r-th largest element, making use of its intermediate steps. During an iteration, one of the following three cases will occur. If the algorithm decides to search a part larger than the pivot, then the discarded part does not contain the largest r elements. If a part smaller than the pivot is selected, then the discarded part is part of the largest r elements. If the pivot is exactly the r-th largest element, then the part larger than the pivot together with the pivot are part of the largest r elements.

In practice, the batch size M is small. We can search these r batches with the highest ranks in $\mathcal{O}\left(\right|\mathcal{L}|+M)$ time using a counting technique as an efficient alternative. The technique is to use part of the counting algorithm [88]. We first compute a histogram of the number of times each rank occurs, taking $\mathcal{O}\left(M\right)$ time for initialization and $\mathcal{O}\left(\right|\mathcal{L}\left|\right)$ time to scan the block. Then, we can scan and count the frequencies of the histogram from the highest rank, and eliminate the part where the count exceeds $\ell \mathrm{mod}\left|\mathcal{L}\right|$. This takes $\mathcal{O}\left(M\right)$ time. Lastly, we scan the ranks of the batches again in $\mathcal{O}\left(\right|\mathcal{L}\left|\right)$ time. If included in the modified histogram, we add 1 to the corresponding $t_b$ and minus 1 to the corresponding frequency in the histogram.

Algorithm 2 is a $(1-p)$-approximation algorithm, although the relative performance guarantee factor $1-p$ is not tight in general. However, this suggests that the smaller the packet loss rate p, the more accurate the output the algorithm gives. We defer this discussion to Appendix E.

3.3. Speed-Up via Approximation

In this subsection, we discuss the implementation that corrects an approximate solution to an optimal solution for (9). Algorithm 3 is a greedy algorithm that uses any feasible solution of (8) as a starting point. The foreach loop removes the exceeding recoded packets, assigning the released slot to another batch following the iterations in Algorithm 1. This can be regarded as mimicking a replacement of ${\beta }_p(·,·)$ with the smallest possible value for the batch b that violates the constraint $t_b\le t_{\max }^b$. After this, the intermediate solution is a feasible solution to (9). Then, the last loop finds an increase to the objective by reassigning some slots among the batches.

Algorithm 3: Solver for BAR via approximation.

Note that the algorithm may query ${\beta }_p(t_a-1,r_a)$ for $a\in \mathcal{L}$. If $t_a=0$, then it has access to the value ${\beta }_p(-1,r_a)$. Recall that we defined ${\beta }_p(-1,·)=1$, the upper bound of ${\beta }_p(·,·)$ by (10). Therefore, these values act as barriers to prevent outputting a negative number of recoded packets.

Theorem 4.

Let ${\left\{t_b\right\}}_{b\in \mathcal{L}}$ be an approximate solution of (8) computed in $\mathcal{O}\left(T_{\mathit{approx}}\right)$ time. Algorithm 3 can be run in $\mathcal{O}(T_{\mathit{approx}}+|\mathcal{L}|+{\sum }_{b\in \mathcal{L}}|t_b^{*}-t_b|log|\mathcal{L}\left|\right)$ time.

Proof. 

The assignments before the foreach loop takes $\mathcal{O}(T_{\mathrm{approx}}+|\mathcal{L}\left|\right)$ time. There are a total of ${\sum }_{b\in \mathcal{L}}|t_b^{*}-t_b|/2$ iterations in the loops. The queries for the minimum and maximum values can be implemented using a min-heap and a max-heap, respectively. Similar to Algorithm 1, we can use binary heaps, taking $\mathcal{O}\left(\right|\mathcal{L}\left|\right)$ initialization time, $\mathcal{O}\left(1\right)$ query time, and $\mathcal{O}(log|\mathcal{L}\left|\right)$ update time. Each iteration contains at most two heap queries and four heap updates. The update of the set T can be performed implicitly by setting ${\beta }_p(t_a,r_a)$ to 0 during the heap updates for $a\in T$. The overall time complexity is then $\mathcal{O}(T_{\mathrm{approx}}+|\mathcal{L}|+{\sum }_{b\in \mathcal{L}}|t_b^{*}-t_b|log|\mathcal{L}\left|\right)$. □

In the last while loop, we need to query the minimum of ${\beta }_p(t_a-1,r_a)$ and the maximum of ${\beta }_p(t_b,r_b)$. It is clear that we need to decrease the key ${\beta }_p(t_b,r_b)$ to ${\beta }_p(t_b+1,r_b)$ in the max-heap, and increase the key ${\beta }_p(t_a-1,r_a)$ to ${\beta }_p(t_a-2,r_a)$ in the min-heap. However, we can omit the updates for batches a and b in the max-heap and min-heap, respectively, i.e., reduce from four heap updates to two heap updates. We defer this discussion to Appendix G.

3.4. Construction of the Lookup Table

In the above algorithms, we assume that we have a lookup table for the function ${\beta }_p(·,·)$ so that we can query its values quickly. In this subsection, we propose an on-demand approach to construct a lookup table by dynamic programming.

Due to the fact that ${\sum }_{i=0}^t{B}_p(t,i)=1$, we have

$$0\le {\beta }_p(t,r)\le 1.$$

(10)

Furthermore, it is easy to see that

$$\begin{array}{ccccccc}\hfill {\beta }_p(t,r)& =\hfill & \hfill 0& \mathrm{if}\mathrm{and}\mathrm{only}\mathrm{if}\hfill & r& =& 0\mathrm{and}t\ge 0;\end{array}$$

(11)

$$\begin{array}{ccccccc}\hfill {\beta }_p(t,r)& =\hfill & \hfill 1& \mathrm{if}\mathrm{and}\mathrm{only}\mathrm{if}\hfill & t& \le & r-1.\end{array}$$

(12)

A tabular form of ${\beta }_p$ is illustrated in Figure 4 after introducing the boundaries 0 and 1 s.

Being a dynamic programming approach, we need the following recursive relations:

$$\begin{array}{cccc}\hfill B_p(t+1,r)& =\hfill & (1-p)B_p(t,r-1)+p{B}_p(t,r)& \mathrm{for}0\le r\le t;\end{array}$$

(13)

$$\begin{array}{cccc}\hfill B_p(r,r)& =\hfill & (1-p)B_p(r-1,r-1)& \mathrm{for}r>0;\end{array}$$

(14)

$$\begin{array}{cccc}\hfill {\beta }_p(t,r)& =\hfill & {\beta }_p(t,r-1)+B_p(t,r-1)& \mathrm{for}1<r\le t+1,\end{array}$$

(15)

where (13) is stated in Lemma 1(a); and (14) and (15) are by the definitions of $B_p(t,r)$ and ${\beta }_p(t,r)$, respectively. The boundary conditions are $B_p(0,0)=1$, $B_p(i,-1)=0$, and ${\beta }_p(i,1)=B_p(i,0)$ for $i=0,1,\dots$. The table can be built in-place in two stages. The first stage fills in $B_p(y,x-1)$ at the $(y,x)$ position of the table. The second stage finishes the table by using (15). Figure 5 illustrates the two stages where the arrows represent the recursive relations (13)–(15). As ${\beta }_p(0,1)={\beta }_p(1,2)=\dots =1$, the corresponding entries can be substituted in directly.

We can compute the values in the table on-demand. Suppose we have ${\left\{t_b\right\}}_{b\in \mathcal{L}}$ in an iteration of Algorithm 1 so that we need the values of ${\beta }_p(t_b,r_b)$ for $b\in \mathcal{L}$. Let $b^{\prime }$ be an element in ${arg\; max}_{b\in \mathcal{L}}{r}_b$. The table has $r_{b^{\prime }}+1$ columns. By the criteria of selecting b in Algorithm 1 and by Lemmas 1(c) and (d),we have ${max}_{b\in \mathcal{L}}{t}_b=t_{b^{\prime }}$. From Figure 5, we know we have to calculate all rows of $\beta (t,r)$ for $t\le t_{b^{\prime }}$. Furthermore, the recursive relations on a row only depend on the previous row; thus, we need to prepare the values of $B_p$ in the next row so that we have the values to compute ${\beta }_p$ in the next row. As an example, Figure 6 illustrates the values we have prepared when $t_{b^{\prime }}=2$.

Each entry in the table is modified at most twice during the two stages. Each assignment takes $\mathcal{O}\left(1\right)$ time. Therefore, the time and space complexities for building the table are both $\mathcal{O}\left(MR\right)$, where R is the number of rows we want to construct. When restricted by the block size, we know that $R\le t_{\max }^{\mathcal{L}}$. The worst case is that we only receive one rank-M batch for the whole block, which is unlikely to occur. In this case, we have the worst case complexity $\mathcal{O}\left(M{t}_{\max }^{\mathcal{L}}\right)$.

Note that we can use fixed-point numbers instead of floating point numbers for a more efficient table construction. Furthermore, the numerical values in the table are not important as long as the orders for any pair of values in the table are the same.

3.5. Throughput Evaluations

We now evaluate the performance of BAR in a feedbackless multi-hop network. Note that baseline recoding is a special case of BAR with block size 1. Our main goal here is to show the throughput gain of BAR among different block sizes. In the evaluation, all (recoded) packets of a batch are sent before sending those of another batch.

Let $(h_0,h_1,\dots ,h_M)$ be the incoming rank distribution of batches arriving at a network node. The normalized throughput at a network node is defined as the average rank of the received batches divided by the batch size, i.e., ${\sum }_{i=0}^{M}i{h}_i/M$. In our evaluations in this subsection, we set $t_{\max }^{\mathcal{L}}=M\left|\mathcal{L}\right|$ for every block $\mathcal{L}$. That is, the source node transmits M packets per batch. We assume that every link in the line network has independent packet loss with the same packet loss rate p. In this topology, we set a sufficiently large $t_{\max }^b$ for every batch, say, $t_{\max }^b=t_{\max }^{\mathcal{L}}$.

We first evaluate the normalized throughput with different batch sizes and packet loss rates. Figure 7 compares adaptive recoding (AR) and baseline recoding (BR) when we know the rank distribution of the batches arriving at each network node before the node applies BAR. In other words, Figure 7 shows the best possible throughput of AR. We compare the effect of block sizes later. We observe that

• AR has a higher throughput than BR under the same setting;
• the difference in throughput between AR and BR is larger when the batch size is smaller, the packet loss probability is larger, or the length of the line network is longer.

In terms of throughput, the percentage gains of AR over BR using $M=4$ and $p=0.2$ are 23.3 and 33.7% at the 20-th and 40-th hops, respectively. They become 43.8 and $70.3\%$, respectively, when $p=0.3$.

Although the above figure shows that the throughput of BNC with AR maintains a good performance when the length of the line network is long, many applications use a much shorter line network. We zoom into the figure for the first 10 hops in Figure 8 for practical purposes.

Now, we consider the effect of different block sizes. Figure 9 shows the normalized throughput of different $\left|\mathcal{L}\right|$ and p with $M=8$. The first 10 hops in Figure 9 are zoomed in in Figure 10. We observe that

• a larger $\left|\mathcal{L}\right|$ results a better throughput;
• using $\left|\mathcal{L}\right|=2$ already gives a much larger throughput than using $\left|\mathcal{L}\right|=1$;
• using $\left|\mathcal{L}\right|>8$ gives little extra gain in terms of throughput.

Next, we show the performance of the equal opportunity approximation scheme. Figure 11 compares the normalized throughput achieved by Algorithm 2 (AS) and the true optimal throughput (AR). We compare the best possible throughput of AR here, i.e., the same setting as in Figure 7. The first 10 hops in Figure 11 are zoomed in in Figure 12. We observe that

• the approximation is close to the optimal solution;
• the gap in the normalized throughput is smaller when the batch size is larger, the packet loss probability is smaller, or the length of the line network is shorter.

4. Impact of Inaccurate Channel Models

In this section, we first demonstrate that the throughput of BAR is insensitive to inaccurate channel models and packet loss rates. Then, we investigate the feedback design and show that although feedback can enhance the throughput, the benefit is insignificant. In other words, BAR works very well without the need of feedback.

4.1. Sensitivity of ${\beta }_p(t,r)$

We can see that our algorithms only depend on the order of the values of ${\beta }_p(·,·)$; therefore, it is possible that the optimal ${\left\{t_b\right\}}_{b\in \mathcal{L}}$ for an incorrect p is the same for a correct p. As shown in Figure 4, the boundaries 0 and 1 s are unaffected by $p\in (0,1)$. That is, we only need to investigate the stability of ${\beta }_p(t,r)$ for $t\ge r>0$. We calculate values of ${\beta }_p(t,r)$ corrected to four digital places in Figure 13 for $M=4$, and $p=0.1,0.45$ and their 1% relative changes. We can see that the order of the values are mostly the same when we slightly change p.

We can also check with the condition number [89] to verify the stability. Roughly speaking, the relative change in the function output is approximately equal to the condition number times the relative change in the function input. A small condition number of ${\beta }_p(t,r)$ means that the effect of the inaccurate p is small. As shown in Figure 13, the values of ${\beta }_p(t,r)$ drop quickly when t increases. In the view of the throughput, which is proportional to the sum of these values, we can tolerate a larger relative change, i.e., a larger condition number, when ${\beta }_p(t,r)$ is small. We calculate condition numbers of ${\beta }_p(t,r)$ in Figure 14 by the formula stated in Theorem 5.

Theorem 5.

Let $p\in (0,1)$ and $t\ge r>0$. The condition number of ${\beta }_p(t,r)$ with respect to p is $\frac{p^{t-r+1}{(1-p)}^{r-1}t!}{I_p(t-r+1,r)(t-r)!(r-1)!}$, or equivalently, $\frac{{\sum }_{j=0}^{r-1}{(-1)}^j\left(\genfrac{}{}{0pt}{}{r-1}{j}\right)p^{t-r+j+1}}{{\sum }_{j=0}^{r-1}{(-1)}^j\left(\genfrac{}{}{0pt}{}{r-1}{j}\right)p^{t-r+j+1}/(t-r+j+1)}$.

Proof. 

See Appendix F. □

4.2. Impact of Inaccurate Channel Models

To demonstrate the impact of an inaccurate channel model, we consider three different channels to present our observations.

• ch1: independent packet loss with constant loss rate $p=0.45$.
• ch2: burst packet loss modelled by the GE model illustrated in Figure 2 with the parameters used in [70], namely $p_{\mathsf{G}\mathsf{B}}=p_{\mathsf{B}\mathsf{G}}=p_{\mathsf{G}}=0.1$, $p_{\mathsf{B}}=0.8$.
• ch3: independent packet loss with varying loss rates $p=0.45+0.3sin(2\pi c/1280)$, where c is the number of transmitted batches.

All the three channels have the same average packet loss rate of $0.45$. The formula of ch3 is for demonstration purpose only.

We now demonstrate the impact of inaccurate p on the throughput. We consider a line network where all the links use the same channel (ch1, ch2, or ch3). In this topology, we set a sufficiently large $t_{\max }^b$ for every batch, say, $t_{\max }^b=t_{\max }^{\mathcal{L}}$. Similar to the previous evaluation, all (recoded) packets of a batch are sent before sending those of another batch. Furthermore, we set $t_{\max }^{\mathcal{L}}=M\left|\mathcal{L}\right|$ for every block $\mathcal{L}$.

In Figure 15 we plot the normalized throughput of the first 80 received blocks at the fourth hop where $\left|\mathcal{L}\right|=M=4$ or 8. We use BAR with (2) for each network although ch2 is a bursty channel. The black curves with BAR are the throughput of BAR where the loss rate is known. For ch1 and ch2, this loss rate p is a constant of $0.45$. The red and blue curves are the throughput of BAR when we guess $p=0.65$ and $0.25$, respectively, which is $\pm 0.2$ from the average loss rate of $0.45$. As there is no feedback, we do not change our guess on p for these curves. We can see that the throughput is actually very close to the corresponding black curves. This suggests that in the view of the throughput, BAR is not sensitive to p. Even with a wild guess on p, BAR still outperforms BR, as illustrated by the green curves. Regarding ch2, we also plot the orange curve with GE BAR, which is the throughput achieved by BAR with (3). We can see that the gap between the throughput achieved by BAR with (2) and (3) is very small. As a summary of our demonstration:

• We can use BAR with (2) for bursty channels and the loss in throughput is insignificant.
• BAR with an inaccurate constant p can achieve a throughput close to the one when we have the exact real-time loss rate.
• We can see a significant throughput gain from BR by using BAR even with inaccurate channel models.

4.3. Feedback Design

Although an inaccurate p can give an acceptable throughput, we can further enhance the throughput by adapting the varying p values. To achieve this goal, we need to use feedback.

We adopt a simple feedback strategy which lets the next node return the number of received packets of the batches for the current node to estimate p. Although the next node does not know the number of lost packets per batch, it knows the number of received packets per batch. Therefore, we do not need to introduce more overhead to the transmitted packets by the current node.

When we estimate p, we have to know the number of packets lost during a certain time frame. If the time frame is too small, the estimation is too sensitive so the estimated p changes rapidly and unpredictably. If the time frame is too long, we captured too much out-dated information about the channel so the estimated p changes too slowly and may not be able to adapt to the real loss rate. Recall that the block size is not large as we want to keep the delay small. We use a block as an atomic unit of the time frame. The next node gives feedback on the number of received packets per block. The current node uses the feedback of the blocks in the time frame to estimate p. We perform an estimation of p per received feedback. In this way, the estimated p is the same for each block so that we can apply BAR with (2).

If the feedback is sent via a reliable side channel, then we can assume that the current node can always receive the feedback. However, if the feedback is sent via an unreliable channel, say, the reverse direction of the same channel the data packets were sent from, then we need to consider feedback loss. Let $\mathrm{\Lambda }$ be a set of blocks in a time frame with received feedback. We handle the case of feedback loss by considering the total number of packets transmitted for the blocks in $\mathrm{\Lambda }$ as the total number of packets transmitted during the time frame. In this way, we can also start the estimation before a node sends enough blocks to fill up a time frame. Suppose no feedback is received for every block in a time frame, then we reuse the previously estimated p for BAR.

At the beginning of the transmission, we have no feedback yet so we have no information to estimate p. To outperform BR without the knowledge of p, we can use the approximation of BAR given by Algorithm 2. Once we have received at least one feedback, we can then start estimating p.

4.4. Estimators

Let x and n be the total number of packets received by the current node and the total number of packets transmitted by the previous node, respectively, in a time frame for observation. That is, the number of packets lost in the time frame is $n-x$. We introduce three types of estimators for our numerical evaluations.

(1) Maximum likelihood estimator (MLE): The MLE, denoted by ${\widehat{p}}_{\mathsf{MLE}}$, estimates p by maximizing the likelihood function. ${\widehat{p}}_{\mathsf{MLE}}=(n-x)/n$ is a well-known result which can be obtained via derivative tests. This form collides with the sample average, so by the law of large numbers, ${\widehat{p}}_{\mathsf{MLE}}\to p$ when $n\to \infty$ if p does not change over time.

(2) Minimax estimator: The minimax estimator achieves the smallest maximum risk among all estimators. With the popular mean squared error (MSE) as the risk function, it is a Bayes estimator with respect to the least favourable prior distribution. As studied in [90,91], such prior distribution is a beta distribution $\mathsf{Beta}(\sqrt{n}/2,\sqrt{n}/2)$. The minimax estimator of p, denoted by ${\widehat{p}}_{\mathsf{MM}}$, is the posterior mean, which is $\frac{\sqrt{n}}{1+\sqrt{n}}\frac{n-x}{n}+\frac{1}{1+\sqrt{n}}\frac{1}{2}$, or equivalently, $\frac{n-x+0.5\sqrt{n}}{n+\sqrt{n}}$.

(3) Weighted Bayesian update: Suppose the prior distribution is $\mathsf{Beta}(a,b)$, where the hyperparameters can be interpreted as a pseudo-observation having a successes and b failures. Given a sample of s successes and f failures from a binomial distribution, the posterior distribution is $\mathsf{Beta}(a+s,b+f)$. To fade out the old samples captured by the hyperparameters, we introduce a scaling factor $0\le \gamma \le 1$ and let the posterior distribution be $\mathsf{Beta}(\gamma a+s,\gamma b+f)$. This factor can also prevent the hyperparameters from growing indefinitely. The estimation of p, denoted by ${\widehat{p}}_{\mathsf{Bayes}}$, is the posterior mean with $s=n-x$ and $f=x$, which is $\frac{\gamma a+n-x}{\gamma (a+b)+n}$. To prevent a bias when there are insufficient samples, we select a non-informative prior as the initial hyperparameters. Specifically, we use the Jeffreys prior, which is $\mathsf{Beta}(1/2,1/2)$.

We first show the estimation of p by different schemes in Figure 16. We use BAR with (2) and $\left|\mathcal{L}\right|=M=4$. The size of the time frame is W blocks. For ${\widehat{p}}_{\mathsf{MLE}}$ and ${\widehat{p}}_{\mathsf{MM}}$, the observations in the whole time frame have the same weight. For ${\widehat{p}}_{\mathsf{Bayes}}$, the effect of each observation deceases exponentially faster. We consider an observation is out of the time frame when it is scaled into 10% of the original value. That is, we define the scaling factor by $\gamma =\sqrt[W]{0.1}$. In each subplot, the black curve is the real-time p. The red and blue curves are for the estimation without and with feedback loss, respectively. In each case, the two curves are the 25 and 75% percentiles from 1000 runs, respectively.

We can see that a larger W has a slower response to the change in p in ch3. Among the estimators, ${\widehat{p}}_{\mathsf{Bayes}}$ has the fastest response speed as its observations in the time frame are not fairly weighted. Furthermore, although ch1 and ch2 have the same average loss rate, the estimation has a larger variance when the channel is bursty.

4.5. Throughput Evaluations

As discussed in Section 4.2, the guessed p values have an insignificant impact on the throughput. We now show the throughput achieved by the estimation schemes in Figure 17. The parameters for the networks and BAR are the same as in Section 4.2. We do not wildly guess p here so it is no surprise that we can achieve nearly the same throughput as when we know the real p for ch1 and ch2. If we look closely, we can see from Figure 15 that for ch3, there is a small gap between the throughput of BAR when we know the real-time p and the one of BAR when using a constant p. Although the estimation may not be accurate at all times, we can now adapt to the change in p to finally achieve a throughput nearly the same as when we know the real-time p. On the other hand, whether the feedback is lost or not, the plots shown in Figure 17 are basically the same.

5. Conclusions

We proposed BAR in this paper which can adapt to variations in the incoming channel condition. In a practical perspective, we discussed how to calculate the components of BAR and how to solve BAR efficiently. We also investigated the impact of an inaccurate channel model on the throughput achieved by BAR. Our evaluations showed that

• BAR is insensitive to the channel model: guessing the loss rate still outperforms BR.
• For bursty channels, the throughput achieved by BAR with an independent loss model is nearly identical to one with the real channel model. That is, we can use the independent loss model for BAR in practice and apply the techniques in this paper to reduce the computational costs of BAR.
• Feedback can slightly enhance the throughput for channels with a dynamic loss rate. This suggests that BAR works very well without the need of feedback. On the other hand, feedback loss barely affects the throughput of BAR. Therefore, we can send the feedback through a lossy channel without the need of retransmission. Unless we need to use an accurate estimated loss rate in other applications, we can use MLE with a small time frame for BAR to reduce the computational time.

These encouraging results suggest that BAR is suitable to be deployed in real-world applications.

One drawback of our proposed scheme is that we need to change the default behaviour of some intermediate network nodes, which can be a practical problem in existing networks. In fact, this is a common issue for all network coding schemes. Some routers have hard-wired circuits to efficiently handle heavy traffic, so it is unfeasible to deploy other schemes on them without replacing the hardware. For these heavy-loaded nodes, one may consider producing a hardware to speed up the network coding operations, e.g., [92,93], inducing extra costs on the deployment. On the other hand, the protocol for BNC is not standardized yet, meaning two parties may adopt BAR with incompatible protocols, thus restricting the application of BNC in public networks. However, it is not easy to build a consensus on the protocol, because there are still many research directions to improve the performance of BNC so the protocol design is subject to change in the near future.

6. Patents

The algorithms in Section 3 are variants of those that can be found in the U.S. patent 10,425,192 granted on 24 September 2019 [94]. The linear programming-based algorithm for BAR in Appendix H can be found in the U.S. patent 11,452,003 granted on 20 September 2022 [95].