Tunable Sparse Network Coding for Multicast
Networks
Soheil Feizi1 , Daniel E. Lucani2 , Chres W. Sørensen2 , Ali Makhdoumi1 , Muriel Médard1
1 Research
Laboratory of Electronics, Massachusetts Institute of Technology, Cambridge, MA 02139, USA
2 Department of Electronic Systems, Aalborg University, Denmark
Email:{sfeizi, makhdoum, medard}@mit.edu; {del,cws}@es.aau.dk
Abstract—This paper shows the potential and key enabling to introduce end-to-end redundancy instead of introducing
mechanisms for tunable sparse network coding, a scheme in redundancy as required in each link. Thus, the entire network
which the density of network coded packets varies during a must pay for the worst link. These inefficiencies can be quite
transmission session. At the beginning of a transmission session,
sparsely coded packets are transmitted, which benefits decoding significant if the last hop/link has higher packet loss rates
complexity. As the transmission continues and the receivers have than the others, which is a common scenario for end-users
accumulated coded packets, the coding density is increased. We connecting via wireless technologies. Another drawback is
propose a family of tunable sparse network codes (TSNCs) when the losses occur over several links. Then, the lack of
for multicast erasure networks with a controllable trade-off re-encoding means that, the end-to-end coding throughput is
between completion time performance to decoding complexity.
Coding density tuning can be performed by designing time- reduced cumulatively by the losses in the network, whereas
dependent coding matrices. In multicast networks, this tuning can it needs only suffer the worst case losses in the case of
be performed within the network by designing time-dependent network coding, thus achieving the min-cut [6] even without
pre-coding and network coding matrices with mild conditions side information about the losses [7]. Previous work, e.g., [9],
on the network structure for specific densities. We present proposed overlapping dense generations to improve throughput
a mechanism to perform efficient Gaussian elimination over
sparse matrices going beyond belief propagation but maintaining with reasonable complexity, yet it still relies on Gaussian
low decoding complexity. Supporting implementation results are elimination techniques for decoding. On the other hand, [10]
provided showing the trade-off between decoding complexity and proposed BATS codes, which use code concatenation of sparse
completion time.
generations, i.e., generations created with a specific and fixed
degree distribution, with traditional erasure codes to exploit
I. I NTRODUCTION
Since its introduction over a decade ago by Alhswede et al belief propagation decoding. Our goal is to understand a new
[1], network coding has evolved from an information theoretic dimension in the process, namely, the evolution of the code
result for achieving capacity in multicast to become an enabler structure as the transmission process advances.
This paper shows the potential of tunable sparse network
of a wide variety of applications, including communications in
ad-hoc networks, data gathering in sensor networks, and data coding (TSNC), an idea originally presented in [13]. TSNC
storage. Network coding encourages the mixing (coding) of constitutes a scheme that relies on tuning the density of coded
data packets at intermediate nodes, rather than limiting inter- packets over the network during a transmission session, where
mediate nodes to store and forward packets as in traditional a session lasts from the time the source starts to transmit
networks. Under this premise, it is no longer required for the until it delivers n original packets to the destinations. At the
system to keep track of which packets have been received: beginning of the session, sparse codes are used while the
receivers need only aim at accumulating enough coded packets code’s density is increased as the receivers gather more degrees
in order to recover the information. Ref. [2] showed that of freedoms (dofs), i.e., independent linear combinations of
linear codes over a network are sufficient to achieve multicast the original packets. Growth codes [8] have considered a
capacity. Ref. [3] proposed random linear network coding similar idea, i.e., to change the density of the code in time,
(RLNC) a distributed approach that randomly generates linear with the goal of maximizing the probability that each packet
is immediately decodable for a receiver using field size F2 .
codes achieving capacity with high probability (w. h. p.).
One of the key arguments against the use of RLNC is that However, we are not concerned with immediate decodability.
its decoding complexity is O(n3 ), where n is the number of Instead, we allow the system to choose the code density to
original packets. To have more efficient decoders, the idea of meet a specific balance between completion time and decoding
using sparse codes instead of dense ones has been developed complexity over different field sizes Fq . This paper provides
in different applications. Sparse end-to-end correcting codes, examples of families of codes that can be used to maintain
such as LT [4] and Raptor codes [5], reduce the decoding load a given overhead target, ranging from a constant overhead
on the receiver but at the cost of introducing additional, non- irrespective of the number of packets to transmit (n), to a
negligible delay. At the crux of this inefficiency lies the use fixed percentage of overhead that varies with the n. In this
of a code with a static and sparse distribution that reduces the sense, Growth codes, as well as RLNC and LT codes, can be
impact of each coded packet as the transmission progresses, considered special instances of TSNC.
With the goal of characterizing TSNC, this work makes the
an effect that becomes critical when only a small number
of linearly independent packets are needed to decode the following contributions, categorized into three main questions:
Q1: From the perspective of a receiver with i received dofs
data. Another important source of inefficiencies for end-toend correcting codes is that, they lack RLNC’s capability to out of n packets, what is an optimal/suboptimal density for the
re-encode at intermediate nodes. This in turn forces the source next received coded packet? Intuitively, when i << n, receiv-
ing sparse coded packets is beneficial, since they potentially
decrease decoding complexity and yet since few dofs have
been received, a sparse coded packet would be innovative with
high probability. However, when i n (i.e., i is of the order
of n), coding density should be increased, since sparse coded
packets would no longer be innovative w. h. p.. We investigate
this question in Section III.
Q2: How can a coded packet with a specific coding density
be delivered to receivers through a network? We investigate
this question in Section IV in two cases. The first case is when
the required coding density at the receivers is greater than the
scaled min-cut rate of the network. For this case, we introduce
a network coding scheme for a general multicast network that
can deliver the required coding density to the receivers by
using time-dependent pre-coding matrices and using RLNC
over the network. For the second case, we introduce a family
of multicast networks, called k-sparse networks, for which,
by designing pre-coding and network coding matrices, code
density tuning can be performed over the network.
Q3: For the sparse coding matrices yielded by TSNC, how
can a Gaussian elimination algorithm be performed efficiently
in the decoding process? We investigate this question in
Section V by extending the mechanism in [13] to perform
efficient Gaussian elimination over sparse matrices.
We characterize TSNC by answering Q1, Q2 and Q3 and
providing supporting simulation results (Section VI).
Although we presented some of the initial insight of TSNC
in [13], particularly providing some answers to Q1 and making
an initial proposal for Q3, our current work provides a
significant advance with respect to [13]. First, we provide
a framework to design the correct evolution of density of
TSNC given a desired completion time (delay) performance.
We answer Q1 with a general framework that characterizes the
trade-off between delay and density, which in turn determines
decoding complexity at the receivers. Further, we provide an
answer to Q2 that allows us to use RLNC for recoding at
intermediate nodes (under some mild conditions) to maintain
provably the sparse structure of the code as packets traverse
the network. Finally, we use the intuition of the algorithm
in [13] to provide a more efficient and iterative version of
the algorithm to answer Q3. The iterative nature of our
new proposal allows us to exploit the sparse structure more
efficiently with similar complexity guarantees.
II. M ODEL AND P RELIMINARIES
In this paper, we consider multicast networks with one
source and several receivers. We model the network as a directed graph, where edge erasure probabilities are independent.
This assumption may be relaxed in future studies, but it is a fair
assumption in many networks. Suppose the source node has n
packets to transmit to a subset of the nodes in the network, i.e.,
a multicast transmission session. X is a n × 1 vector of source
packets whose ith component, Xi , represents the ith source
packet in the finite field Fq , where Fq represents a prime or
an extended field. A coded packet is innovative to a receiver
if it is linearly independent from previously received dofs.
We have a discrete time, discrete packet model, where, in the
absence of erasures, a link delivers one packet per round (time
slot). Parallel edges can be used to model physical links with
higher capacity. The minimum min-cut between each receiver
and source is m. Therefore, the network can deliver m packets
at each transmission round (the overhead of the coding vector
is neglected [2]). A transmission session is complete when
all destination nodes receive n source packets. Assume that
m << n, so that multiple transmission rounds are required in
a transmission session.
For an error-free network, [2] shows that, after each transmission round, receiver j receives Aj X, where Aj can be
selected to be a m × n matrix of rank m (since the min-cut
rate is m). Aj is called the network coding matrix associated
with the receiver j . This matrix can be decomposed into two
matrices, B and Gj (i.e., Aj = Gj B). B is a n × n pre-coding
matrix which is applied at the source node. This matrix is the
same for all receivers. Gj is a m × n matrix representing the
effect of performing network coding at different nodes of the
network from the source node to the receiver j .
For this analysis, we consider a probabilistic packet erasure
model over different edges where erasures are i.i.d. within a
link and independent across different links. Since some packets
are lost as they traverse the network, the probabilistic min-cut
rate of this network is smaller than the error-free min-cut rate
of the network (i.e., m).
For the receiver j , define a m × m diagonal matrix Pj
whose bth component on the diagonal (i.e., Pb,b ) is zero with
probability pb , and one with probability 1−pb . Probabilities pb
depend on edge erasure probabilities. Hence, at the end of each
transmission round, the destination node j , receives Pj Aj X.
Packet erasures reduce the
min-cut rate of the network from
1 Pm P
m to αm, where α = m
b=1 b,b ≤ 1, with high probability.
Each transmission round is indexed by t. The received coded
packets at receiver j in the transmission round t, are denoted
by Y(t) = Pj Aj (t)X. In RLNC, the statistical properties of
the matrix Aj (t) do not vary in time. However, in TSNC this
matrix depends on t. In fact, this time dependency is the key
to enabling a better trade-off between the decoding complexity
and the completion time. The performance metric is the
expected number of transmission rounds in a transmission
session, which we refer to as completion time and define as:
T , E min rank(Pj Aj (t) = n) ,
t
∀j.
(1)
In this work, we say a coded packet is innovative for a receiver
if it increases rank of its coding matrix, i.e., it adds a degree
of freedom to the receiver. A coded packet is k-sparse if
it contains k non-zero coding coefficients from Fq \{0}. The
density of a k-sparse packet is the fraction of the non-zero
coefficients to the total number of original packets, i.e., k/n.
Throughout the paper, we assume the finite field size q is
sufficiently large such that decodability is not impacted by it,
i.e., field size never leads to having a matrix whose rank could
have been higher through a choice of larger q [2].
The density of a matrix Aj (t) is the ratio of its non-zero
components and is denoted by ρ(Aj (t)). By abuse of notation,
the density of a coded packet aij (t) (i.e., i-th row of the matrix
j
Aj (t)) is also denoted by ρ(ai (t)), which is the fraction of its
non-zero components. A coding matrix (or a coded packet) is
dense if this ratio is high (close to one). Otherwise, the matrix
is sparse. For example, in RLNC, Aj (t) is dense w.h.p.
In this work, we focus on an open loop approach where
there is no feedback from receivers but prior knowledge of
the network’s erasure probabilities is available. However, our
formulation and techniques naturally extend and benefit from
available feedback from the receivers. Section III characterizes
key mechanisms to tune sparsity in order to provide a given
completion time performance. We focus on the perspective of
one receiver for a general multicast network (addressing Q1).
III. S PARSITY T UNING
Suppose a receiver has i dofs out of n source packets. At the
next time, it receives m sparse coded packets with a density
ρ(i, n). For each packet, p(i, n) is the probability of being
innovative. The following theorem relates ρ(i, n) and p(i, n).
Theorem 1. The probability p(i, n) of a received coded packet
with density ρ(i, n) ≤ 1/2 to be innovative when the receiver
already has i out of n dofs is
(2)
Proof: To prove this theorem, we use Lemma 1.
Lemma 1. Suppose V = Fn
q and U be a subspace of V with
dimension i. For any v ∈ V , consider the following probability
measure:
1 − P0 n−k
,
q−1
where k is the number of zero elements of v (i.e., w(v) , n−k)
and q ≥ P10 . Then, P r(U ) ≤ P0n−i .
Proof: Suppose E is the set of all vectors in V with only
one non-zero component. There exists a subspace of V denoted
by U 0 with dimension n − i,L
orthogonal toLU and has a basis
from E . Therefore, V = U U 0 where
represents direct
sum of two subspaces. Now, suppose u0 ∈ U 0 has k non-zero
components. Therefore
P r(U + u0 ) =
P r(u + u0 )
X
u∈U
≥
X
P r(u)
u∈U
k
k
1 − P0
1 − P0
= P r(U )
.
(q − 1)P0
(q − 1)P0
The lower bound comes from the case when u0 makes k zero
elements of u non-zero. Then we can write,
0
1 = P r(U + U ) =
X
the performance loss in terms of completion time is negligible
since p(i, n) is close to one for i << n. As i n (i is of the
order of n), p(i, n) will be reduced when small ρ(i, n). Hence,
ρ(i, n) should be increased to avoid substantial performance
loss. We now provide a mechanism to exploit Theorem 1 to
tune the density in order to guarantee a given performance in
terms of the completion time.
Definition 1. A density tuning function constitutes the expected overhead (i.e., number of non-innovative packets)
linked to the transmission of packets with a density ρ(i, n)
when the receiver has i dofs, and is related to p(i, n) by
g(i, n) ,
0
P r(U + u )
u0 ∈U 0
X 1 − P w(u0 )
0
(q
−
1)P
0
u0 ∈U 0
!
k
n−i
X n−i
1 − P0
k
= P r(U )
(q − 1)
(q − 1)P0
k
k=0
n−i
1 − P0
= P r(U ) 1 +
= P r(U )P0i−n .
P0
≥ P r(U )
Therefore, P r(U ) ≤ P0n−i .
Using P0 = 1 − ρ(i, n) in Lemma 1 completes the proof.
1
− 1.
p(i, n)
(3)
Theorem 2. The density tuning function g(i, n) is related to
the code density ρ(i, n) as follows:
g(i, n) ≤
p(i, n) ≥ 1 − (1 − ρ(i, n))n−i .
P r(v) , P0k
In TSNC, at the beginning of the transmission session (when
t is small), sparse packets are transmitted. We will show that
(1 − ρ(i, n))n−i
1 − (1 − ρ(i, n))n−i
(4)
Proof: The proof follows from Theorem 1.
P
The mean overhead for the entire process is n−1
i=0 g(i, n).
Different TSNC schemes can be designed by choosing various
density tuning functions g(i, n). The evolution of g(i, n) for
changing i determines the performance
of the system. Thus,
P
g(i,
n)
< B , where B is a
choosing a g(i, n) such that n−1
i=0
constant, results in a scheme with constant overhead and, thus,
a vanishing completion time degradation as n grows.
Example 1. As shown in [11] and [12], g(i, n) = q i−n
for RLNC, which implies that the overhead is bounded by a
constant independent on the number of packets n.
Remark 1. By choosing g(i, n) = (n − i)−2 , the mean
overhead is bounded by a constant independent of the number
of packets n, but without requiring the same density as RLNC.
Fig. 1 shows that the required density is at least an order
of magnitude smaller than RLNC with field size q = 2 and
n = 1000 for most of a transmission session and almost two
orders of magnitude smaller for more than 20% of the session.
Fig. 1 also shows that for g(i, n) = q i−n for q = 2 we get a
constant ρ(i, n) = 0.5, in other words, in average half of the
coefficients are non-zero, which is similar to RLNC with F2 .
Remark 2. Fig. 1 also shows the density when using g(i, n) =
(n−i)−1 and g(i, n) = 0.1. These schemes involve an overhead
of O(ln n) and 0.1n, respectively. The latter maintains a
constant overhead as n increases, while the former has a
diminishing overhead (O(ln n/n)).
Suppose the optimal completion time for transmitting n
packets through the network is Ttot . For m << n, Ttot
converges to n/m0 for large n, where m0 is the probabilistic
min-cut rate of the network. TT SN C is the completion time
of a TSNC scheme.
Definition 2. A TSNC scheme has asymptotically zero performance loss when limn→∞ TT SN C /Ttot = 1.
0
ρ(i,n) = k(i, n) / n
10
−1
10
receivers w. h. p. Note that, since nρ(i, n) > m0 , these coded
packets are innovative to receivers w. h. p.
Now, we consider Case 2, where ρ(i, n) is less than the
scaled min-cut rate of the network. This condition may happen
at the very beginning of the transmission. For this case, we
show that, if the network is sparse enough, coding density
ρ(i, n) can be delivered to receivers.
g(i,n) = 2i−n
g(i,n) = (n−i)−2
g(i,n) = (n−i)−1
g(i,n) = 0.1
Definition 3. We say a network is k-sparse if, for each receiver
j , each row of Aj (t) has at most k non-zero elements.
−2
10
−3
10
0
0.2
0.4
0.6
0.8
i/n ( fraction of #dofs already at the receiver)
1
Fig. 1. Evolution of density versus the fraction of accumulated dofs at the
receiver, given various tuning functions, g(i, n) for n = 1000.
Theorem 3. A tunable sparse network coding scheme has
asymptotically zero performance loss iff
Pn−1
lim
n→∞
i=0 g(i, n) = 0.
n
(5)
Proof: Since 1+g(i, n) represents the expected number of
packets to be received to increase by one the dofs, i.e., from
i to i + 1. For TSNC, the completion time for a receiver is
E[TT SN C ] =
n+
Note that, a zero element in Aj (t) can be due to lack of
physical links (topologically sparse networks) or can be due
to not performing coding in some intermediate nodes. Over
a k-sparse network, under the condition of Case 2, we show
that the following network coding algorithm can deliver coded
packets with density at most ρ(i, n) to receivers:
Algorithm 2. Consider the following network coding scheme:
• Source node uses a random pre-coding matrix B with the
density ρ0 (i, n) with ρ(i, n) ≤ 1 − (1 − ρ0 (i, n))k , where the
network is k-sparse.
• Intermediate nodes in the network perform random linear
network coding. Hence, each receiver obtains Gj BX.
Theorem 5. Under the condition of Case 2, for a k-sparse
network, a network coding scheme presented in Algorithm 2
achieves packet coding density ρ(i, n) at receivers.
Pn−1
i=0 g(i, n) .
m0
Therefore, if the condition of Theorem 3 holds and n → ∞,
we have E[TT SN C ]/n → 1/m0 .
IV. R ECODING IN M ULTICAST N ETWORKS
This section studies cases where coded packets with a
specific coding density ρ(i, n) can be delivered to receivers
via a network without compromising its code structure at the
time of recoding (addressing Q2). We consider two regimes:
• Case 1: ρ(i, n) ≥ m0 /n.
• Case 2: ρ(i, n) < m0 /n.
Recall that a receiver obtains Pj Aj (t)X where Aj (t) =
Gj (t)B(t). In Case 1, we show that the following scheme
delivers packets with a coding density ρ(i, n) to the receivers:
Algorithm 1. Consider the following scheme:
• The source uniformly randomly selects (nρ(i, n))-sparse
packets, out of n packets, denoted by X. Then, it uses a
uniformly random pre-coding matrix B.
• Intermediate nodes perform RLNC on packets from a
single round. Hence, each receiver obtains Gj BX.
Theorem 4. Under the condition of Case 1, a network coding
scheme presented in Algorithm 1 achieves packet coding
density ρ(i, n) at the receivers.
Proof: By using the pre-coding matrix of Algorithm 1,
coded packets with density ρ(i, n) are generated and transmitted over the network. By this choice of m coded packets
and using RLNC at intermediate nodes, coding density ρ(i, n)
will not be changed over the network and will be delivered to
Proof: By using a pre-coding matrix of Algorithm 2, the
source transmits sparsely coded packets with density ρ0 (i, n).
If all pre-coded packets have zero components in an index i
of their blocks, then a coded packet received at the receivers
will have a zero component in that index. Since the network is
assumed to be k-sparse, at most k of these pre-coded packets
can be mixed in the network. Therefore, the probability of
having a zero component in a received coded packet is at
least (1 − ρ0 (i, n))k . Thus, the density of the received coded
packet is at most 1 − (1 − ρ0 (i, n))k w. h. p.
Since m << n for many practical cases, one may ignore
the condition of Case 2 with negligible performance loss.
V. C OMPLEXITY A NALYSIS
The forward pass of the Gaussian elimination algorithm
constitutes the dominant effect towards its computational
complexity. For sparse matrices, the forward pass can create
additional density in coded packets that have not yet been
processed by introducing spurious coefficients. This has a
detrimental effect in complexity affecting the forward and the
backward pass. We propose a simple, yet powerful algorithm
that reorders the matrix to avoid addition and multiplication
operations in the forward pass w.h.p. for the processing of
sparse packets. This approach keeps the number of operations
in the backward pass for the k-sparse packets as O(dk ), where
dk is the number of k-sparse packets (addressing Q3) and is
inspired by our work in [13], which showed a similar result.
Fig. 2 illustrates the case of a transmission using TSNC
with n = 8 source packets. The algorithm counts the number
of times a packet corresponding to columns on the lower righthand side, as defined by the dashed lines, is involved in a
(a) 1 0 2 0 0 1 0 1 0 1 0 0 3 1 2 1 0 0 1 1 4 0 4 0 0 0 0 1 0 0 0 0 (b) 0 0 1 1 0 0 3 0 0 0 0 0 2 3 2 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 1 P1 P2 P3 P4 P5 P6 P7 P8 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 Uses of a packet in coded packets 4 5 4 1 3 3 1 2 under dashed line (d) 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 1 1 0 0 0 0 Uses of a packet in coded packets under dashed line 0 1 0 0 0 0 3 1 3 0 0 0 2 0 2 0 1 0 1 0 0 1 0 2 0 1 0 0 4 0 4 1 1 0 0 1 3 0 2 1 0 1 1 0 0 0 3 0 3 0 0 0 2 0 2 0 1 0 2 0 0 1 0 1 1 0 0 0 0 0 0 1 P7 P4 P3 P2 P5 P6 P1 P8 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 1 1 3 0 2 0 3 3 2 2 3 1 P7 P4 P8 P2 P5 P6 P1 P3 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 1 1 0 0 0 0 0 1 0 0 0 0 3 1 3 0 0 0 2 0 2 0 1 0 1 0 0 1 0 2 0 1 0 0 4 0 4 1 P7 P4 P8 P2 P5 P6 P1 P3 3 2 2 2 3 (e) 2 2 2 3 Fig. 2.
0 1 1 0 4 0 4 0 (c) (f) 1 0 1 0 1 0 0 0 3 1 0 0 0 2 2 0 0 0 0 0 0 0 3 1 0 1 0 0 0 4 4 1 P7 P4 P8 P2 P1 P6 P5 P3 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 1 1 0 0 0 0 2 2 3 1 0 1 0 1 0 0 0 3 1 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 2 0 1 P7 P4 P8 P2 P1 P6 P5 P3 2 1 Example of proposed decoding algorithm (Algorithm 3)
linear combination. Involvement of the packet in combinations
below the dashed line are not counted. These counters can
be increased with each incoming packet and decreased after
processing of each packet for the non-zero values, i.e, O(k)
update operations per received/processed packet. Fig. 2 (a)
shows that packets P4 and P7 have only been used once in
the 8 linear combinations received. We then swap columns 4
and 7 and also swap rows 1 and 6 and rows 2 and 4 resulting in
Fig. 2 (b). Note that only one row/column swap is performed
per packet and only non-zero elements need to be swapped.
Furthermore, column swaps do not affect the coded data, only
the coding coefficients. For Fig. 2 (b) we now identify P8 as
the packet with a single use below the dashed lines. Thus, we
swap columns 3 and 8 and rows 3 and 8. This results in Fig. 2
(c), where we have advanced the dashed lines and updated the
counters. Fig. 2 (c) shows no packet with a single use. Thus,
we could use either row 4 or row 6 to perform a forward
elimination pass, as they are the least dense combinations
available (1-sparse in this case). This forward pass results in
Fig. 2 (d). This step has also no packet with a single use.
We select row 6 for the forward pass and after appropriate
reordering result in Fig. 2 (e). Fig. 2 (e) again shows no single
use of a packet. We then select row 6 again for a forward pass.
In this case, this is a 2-sparse packet. After subtracting row
6 to row 7 and multiplying row 6 by 2−1 we reach to Fig. 2
(f). At this point, we have P3 with a single use and can then
swap rows/columns 7 and 8 to finalize the pass. After this,
backward elimination is performed. We know formalize these
ideas. Define Pi as the i-th original packet, Cj (Z) as the set of
coded packets of j -sparse packets drawn from Z a subset of
the original packets, and S1 as the set of uncoded (1-sparse)
packets. Define U (F, Z) as the set of packets of subset Z used
only once in the set of coded packets F , and Ω as the set of n
packets. The algorithm follows.
Algorithm 3
STEP 0: R(0) = {Ck (Ω) : k > 1}, C(0) = {Pj : Pj 6∈ S1 }
i = 0.
STEP i: If U (R(i), C(i)) 6= ∅
(a) R(i + 1) = R(i) − {Ck (U (R(i), C(i))) : k > 1},
(b) C(i + 1) = C(i) − U (R(i), C(i))
Else (c) If: C(i) = ∅, Stop.
(d) Else: Search sparse packet with least number of
elements in C(i), use it to perform forward elimination
(e) Update R(i + 1) and C(i + 1): remove the coded packet
from R(i), and one of the packets from C(i)
End
i ← i + 1, Go to next step
The decoding complexity of this algorithm outperforms that
presented in [13] by introducing an elimination step that uses
sparse packets, with preference on 1-sparse packets, in case
there are no more original packets used only once. This avoids
the algorithm in [13] to perform standard Gaussian elimination
if there are no columns with a single packet use, thus providing
a lower complexity.
Our algorithm is different from belief propagation, which
limits operations to canceling the effect of 1-sparse packets
on the other coded packets. This can make the algorithm stop
if no 1-sparse packets are available. Using belief propagation
in our example with n = 8 would not be able to decode the
matrix, because it will only eliminate the effect of P1 , P2 , P8
after which no other 1-sparse packets is left. In contrast, we
first avoid operations amongst packets as much as possible,
except when reordering is insufficient. In this case, we attempt
to cancel the effect of the least dense packet available. This
means we prioritize for 1-sparse, but do not necessarily
constrain it to this case. Our goal is to delay the decoding
process until we have an upper triangular matrix. At this time,
backward elimination is performed. The backward elimination
step will be equivalent to use 1-sparse packets on the remaining
coded packets. In our example of Fig. 2, we only had one
elimination (row 7 - row 8 in step (e)) that involved two rows
that were not 1-sparse.
sparser mechanism (e.g., TSNC density/2) provide higher
performance gains. The former has a gain of only 2.5x. The
latter achieves a gain of 4x for less than 10 additional coded
packets (< 1% of overhead) and 6x (and up to 10x) if we
allow overhead of 10% or higher. In practice, the step choices,
overhead target, and evolution will incorporate (a) the effect of
the hardware/software used by the receivers to understand the
possible processing speed supported by the device, and also
(b) the application’s requirements, e.g., delay, throughput.
Fig. 3. Trade-off between processing speed (goodput) and overhead (additional transmitted coded packets) for n = 1024.
VI. P ERFORMANCE E VALUATION
This section illustrates the trade-off between complexity
and delay performance in a first implementation in C++.
For fairness, we employ the same sparse-aware Gaussian
elimination algorithm in [14] to decode all schemes. We compare a simple TSNC scheme, that attempts to target specific
overheads by adapting the density at different threshold points,
to static sparse schemes and RLNC. In all cases, we consider
operations for all schemes are carried out in GF (2). In the
following, we describe the three key schemes.
First, we use a static sparse scheme that transmits k-sparse
packets only. Second, a standard RLNC: scheme. Finally,
we provide a specific family of TSNC Schemes. For our
implementation of TSNC, we defined seven density steps, i.e.,
seven density levels during each transmission round. The levels
are changed when the decoder receives 512, 768, 896, 940, 992,
and 1008 linearly independent coded packets. When reaching
each rank, the decoder notifies the encoder to tune the density
based on (i) the target overhead (overhead budget) and the
overhead incurred so far at the receiver, which determines the
remaining unused overhead budget br , and (ii) the knowledge
of when the signaling is received. Each feedback triggers the
encoder to re-calculate the density to be used based on the
budget available for that step, bstep . This is calculated as
bstep = br · (dofnext − dof )/dofr , where dof represents the
decoder’s current rank, and dofnext is the decoder’s rank at
the rank level of the next density step. For simplicity, we keep
the density fixed until the next received feedback. We use
Theorem 2 to compute the density of a step.
Fig. 3 shows the performance of the three schemes for
n = 1024 packets using different sparsity levels for the static
schemes and different evolutions for ρ(i, n) and different target
overheads for TSNC (same line type). For our tests we use an
Intel Core i5-2400 CPU at 3.1GHz running a Linux operating
system. Fig. 3 shows the case of pure RLNC at 10 MB/s and
various sparse schemes as comparison schemes. Since there is
no adaptation in these cases, a single point is represented.
We observe that using a code density evolution that is denser
from beginning to end (TSNC density/1) is counterproductive
from a processing speed (complexity) perspective, while a
VII. C ONCLUSIONS
This work provides a novel framework to sparse coding
that encourages i) coding at intermediate nodes for multicast
sessions in general networks, ii) the use of evolving code
density as the means to strike the balance between decoding
complexity and delay performance, and iii) the use of any field
size for coding purposes. These characteristics set our work
apart from classical sparse end-to-end erasure correcting codes
and Growth codes [8]. To enable such flexibility in the code
density, a novel algorithm for reordering rows and columns
of a matrix in order to perform efficient Gaussian elimination
in sparse matrices is presented. This algorithm provides linear
decoding complexity of sparse packets w. h. p.
VIII. ACKNOWLEDGEMENTS
This work was financed in part by award No. 016974-002
by AFSOR, the Green Mobile Cloud project (No. DFF - 060201372B) and the TuneSCode project (No. DFF 1335-00125)
both granted by the Danish Council for Independent Research
R EFERENCES
[1] R. Ahlswede, N. Cai, S. Y. R. Li, Yeung, R. W., “Network Information
Flow,” IEEE Trans. Inf. Theory, vol. 46, no. 4, pp. 1204-1216, Jul. 2000
[2] R. Koetter, M. Médard, “An Algebraic Approach to Network Coding,”
IEEE/ACM Trans. Netw., vol. 11, no. 5, pp. 782-795, Oct. 2003
[3] T. Ho, M. Médard, R. Koetter, D.R. Karger, M. Effros, J. Shi, B. Leong,“A
Random Linear Network Coding Approach to Multicast,” IEEE Trans.
Info. Theory, vol. 52, no. 10, pp.4413-4430, Oct. 2006.
[4] M. Luby,“LT-codes,” In 43rd Annu. IEEE FOCS, Vancouver, BC, Canada,
pp. 271280, Nov. 2002.
[5] A. Shokrollahi, “Raptor Codes,” IEEE Trans. Info. Theory, vol. 52, no.
6, pp. 25512567, 2006.
[6] A. F. Dana, R. Gowaikar, R. Palanki, B. Hassibi, M. Effros, “Capacity
of wireless erasure networks,” IEEE Trans. on Info. Theory, vol. 52, no.
3, pp. 789-804, Mar. 2006
[7] D. S. Lun, M. Médard, R. Koetter, M. Effros,“On coding for reliable
communication over packet networks”, Phy. Comm., Vol. 1, no. 1, pp.
3-20, Mar. 2008
[8] A. Kamra, J. Feldman, V. Misra, D. Rubenstein, “Growth codes: Maximizing sensor network data persistence,” in ACM SIGCOMM, 2006
[9] D. Silva, W. Zeng, F. R. Kschischang, “Sparse network coding with overlapping classes,” in Workshop on Net. Cod. Theory and App. (NetCod),
pp.74-79, Jun. 2009
[10] S. Yang, R. W. Yeung, “Coding for a network coded fountain,” in IEEE
Int. Symp. on Info. Theory (ISIT), pp.2647-2651, Jul. 2011
[11] D. E. Lucani, M. Médard, M. Stojanovic, “Random Linear Network
Coding for Time-Division Duplexing: Field Size Considerations,” In IEEE
GLOBECOM, pp.1-6, Hawaii, USA, Nov. 2009
[12] M. Nistor, D. E. Lucani, T. T. V. Vinhoza, R. A. Costa, J. Barros, “On
the Delay Distribution of Random Linear Network Coding,” IEEE Jour.
on Sel. Areas in Comms., vol.29, no.5, pp.1084-1093, May 2011
[13] S. Feizi, D. E. Lucani, M. Medard, “Tunable Sparse Network Coding,”
in Int. Zurich Sem. on Com. (IZS), pp. 107-110, Switzerland, 2012.
[14] M. V. Pedersen, J. Heide, and F. Fitzek, “Kodo: An open and research
oriented network coding library,” Lecture Notes in Computer Science,
vol. 6827, pp. 145152, 2011.