Fountain Codes Based Distributed Storage Algorithms for Large-scale Wireless Sensor Networks

Abstract

We consider large-scale sensor networks with n nodes, out of which k are in possession, (e.g., have sensed or collected in some other way) k information packets. In the scenarios in which network nodes are vulnerable because of, for example, limited energy or a hostile environment, it is desirable to disseminate the acquired information throughout the network so that each of the n nodes stores one (possibly coded) packet and the original k source packets can be recovered later in a computationally simple way from any (1 + \epsilon)k nodes for some small \epsilon > 0. We developed two distributed algorithms for solving this problem based on simple random walks and Fountain codes. Unlike all previously developed schemes, our solution is truly distributed, that is, nodes do not know n, k or connectivity in the network, except in their own neighborhoods, and they do not maintain any routing tables. In the first algorithm, all the sensors have the knowledge of n and k. In the second algorithm, each sensor estimates these parameters through the random walk dissemination. We present analysis of the communication/transmission and encoding/decoding complexity of these two algorithms, and provide extensive simulation results as well

Full text

Page 1

arXiv:0902.1278v1 [cs.IT] 7 Feb 2009
Fountain Codes Based Distributed Storage Algorithms for Large-scale
Wireless Sensor Networks
Salah A. Aly
Dept. of Computer Science
Texas A&M University
College Station, TX 77843
salah@cs.tamu.edu
Zhenning Kong
Dept. of Electrical Engineering
Yale University
New Haven, CT 06520
zhenning.kong@yale.edu
Emina Soljanin
Bell Laboratories
Alcatel-Lucent
Murray Hill, NJ 07974
emina@lucent.com
Abstract
We consider large-scale networks with n nodes, out of
which k are in possession, (e.g., have sensed or collected in
some other way) k information packets. In the scenarios in
which network nodes are vulnerable because of, for exam-
ple, limited energy or a hostile environment, it is desirable
to disseminate the acquiredinformation throughoutthe net-
work so thateach of the n nodes stores one(possiblycoded)
packet and the original k source packets can be recovered
later in a computationally simple way from any (1 + ǫ)k
nodes for some small ǫ > 0.
We developed two distributed algorithms for solving
this problem based on simple random walks and Fountain
codes. Unlike all previously developed schemes, our solu-
tion is truly distributed, that is, nodes do not know n, k
or connectivity in the network, except in their own neigh-
borhoods, and they do not maintain any routing tables. In
the first algorithm, all the sensors have the knowledge of
n and k. In the second algorithm, each sensor estimates
these parameters through the random walk dissemination.
We present analysis of the communication/transmissionand
encoding/decodingcomplexity of these two algorithms, and
provide extensive simulation results as well1.
1Introduction
Wireless sensor networks consist of small devices (sen-
sors) with limited resources (e.g., low CPU power, small
bandwidth, limited battery and memory).
deployed to monitor objects, measure temperature, detect
fires, and other disaster phenomena. They are often used in
They can be
1This work was accomplished while S.A.A and Z.K. were spending a
summer research internship at Bell Labs & Alcatel-Lucent, Murray Hill,
N.J., 2007, and it was submitted as US patent in [2]. They would like to
thank Bell Labs & Alcatel-Lucent staff members for their hospitality.
isolated, hard to reach areas, where human involvement is
limited. Consequently, data acquired by sensors may have
short lifetime, and any processing on it within the network
should have low complexity and power consumption [18].
We consider a large-scale wireless sensor networks with
n sensors. Among them, k ≪ n sensors have collected
(sensed) some information. Since sensors are often short-
lived because of limited energy or hostile environment,it is
desirable to disseminate the acquired information through-
out the network so that each of the n nodes stores one (pos-
sibly coded) packet and the original k source packets can
be recovered in a computationally simple way from any
(1 + ǫ)k of nodes for some small ǫ > 0. Here, the sen-
sors do not know locations of each other, and they do not
maintain any routing tables.
Various solutions to the centralized version of this prob-
lem have been proposed, and are based on well known
coding schemes such as Fountain codes [6] or MDS
codes [16]. To distribute the information from multiple
sources throughout the network so that each node stores
a coded packet as if obtained by centralized LT (Luby
Transform) coding [12], Lin et al. [11] proposed a solu-
tion that uses random walks with traps. To achieve the de-
sired code degree distribution, they employed the Metropo-
lis algorithm to specify transition probabilities of the ran-
dom walks. In this way, the original k source packets are
encoded by LT codes and the decoding process can be done
byqueryingany(1+ǫ)k arbitrarysensors. Becauseofprop-
erties of LT codes, the encoding and decoding complexity
are linear and therefore have low energy consumption.
In the methods of [11], the knowledge of the total num-
berof sensorsn and sourcesk is requiredfor calculatingthe
number of random walks that each source needs to initiate
and for calculating the probability of trapping at each sen-
sor. Another type of global information, namely, the maxi-
mum node degree(i.e., the maximumnumber of neighbors)
in the network, is also required to perform the Metropolis

Page 2

algorithm. However, for a large-scale sensor network, such
global information may not be easy to obtain by each indi-
vidual sensor, especially when there is possibility of change
in topology. Moreover, the algorithms proposed in [11] as-
sume that each sensor encodes only after receiving enough
source packets. This requires each sensor to maintain a
large enough temporary memory buffer, which may not be
practical in real sensor networks.
In this paper, we propose two new algorithms to solve
the distributed storage problem in large-scale sensor net-
works. We refer to these algorithms as LT-Codes based
Distributed Storage-I (LTCDS-I) and LT-Codes based Dis-
tributed Storage-II (LTCDS-II). Both algorithms use sim-
ple random walks without trapping to disseminate source
packets. In contrast to the methods in [11], both algorithms
demand little global information and memory at each sen-
sor. In LTCDS-I, only the values of n and k are needed,
whereas the maximum node degree, which is more difficult
to obtain, is not required. In LTCDS-II, no sensor needs to
know any global information (that is, knowing n and k is
no longer required). Instead, sensors can obtain good es-
timates for those parameters by using some properties of
random walks. Moreover, in both algorithms, instead of
waiting until all the necessary source packets are collected
to do encoding, each sensor makes decisions and performs
encoding online upon each reception of resource packets.
This mechanism reduces the memory demand significantly.
The main contributions of this paper are as follows:
(i) We propose two new algorithms (LTCDS-I and
LTCDS-II) for distributed storage in large-scale sen-
sor networks, using simple random walks and LT
codes. These algorithms are simpler, more robust, and
less constrained in comparison to previous solutions.
(ii) We present complexity analysis of both algorithms,
including transmission, encoding, and decoding com-
plexity.
(iii) We evaluate and illustrate the performance of both al-
gorithms by extensive simulation.
This paper is organized as follows. We start with a short
survey of the related work in Section 2. In Section 3, we
introduce the network model and present Luby Transform
(LT) codes. In Section 4, we propose two LT codes based
distributedstorage algorithmscalled LTCDS-I and LTCDS-
II. We then present simulation studies and provide perfor-
manceanalysis of the proposedalgorithmsin Section 5, and
concluded in Section 6.
2Related Work
The most related work to one presented here is [11, 10].
Lin el al. studied the question “how to retrieve historical
data that the sensors have gathered even if some sensors
are destroyed or disappearedfrom the network?” They ana-
lyzed techniques to increase persistence of sensed data in a
random wireless sensor network, and proposed two decen-
tralized algorithms using Fountain codes to guarantee the
persistence and reliability of cached data on unreliable sen-
sors. They used random walks to disseminate data from
multiple sensors (sources) to the whole network. Based on
the knowledge of the total number of sensors n and sources
k, each source calculates the number of random walks it
needs to initiate, and each sensor calculates the number of
source packets it needs to trap. In order to achieve some de-
sired packet distribution, the transition probabilities of ran-
dom walks are specified by the well known Metropolis al-
gorithm [11].
Dimakis el al. in [4, 6] proposed a decentralized imple-
mentation of Fountain codes that uses geographic routing,
where every node has to know its location. The motivation
for using Fountain codes is their low decoding complexity.
Also, one does not know in advance the degrees of the out-
put nodes in this type of codes. The authors proposed a
randomizedalgorithmthat constructs Fountaincodes over a
grid network using only geographical knowledge of nodes
and local randomized decisions. Fast random walks are
used to disseminate source data to the storage nodes in the
network.
Kamara el al. in [9, 8] proposeda novel techniquecalled
growth codes to increase data persistence in wireless sen-
sor networks, namely, increase the amount of information
that can be recovered at the sink. Growth coding is a lin-
ear technique in which information is encoded in an online
distributed way with increasing degree of a storage node.
Kamara el al. showed that growth codes can increase the
amount of information that can be recovered at any stor-
age node at any time period whenever there is a failure in
some other nodes. They did not use robust or soliton dis-
tributions, but proposed a new distribution depending on
the network condition to determine degrees of the storage
nodes. The motivation for their work was that i) Positions
and topology of the nodes are not known. ii) They assume
a round time of node updates, meaning with increasing the
time t, degree of a symbol is increased. This is the idea be-
hind growth degrees. iii) They provide practical implemen-
tations of growth codes and compare its performance with
other codes. iv) The decoding part is done by querying an
arbitrary sink, if the original sensed data has been collected
correctly then finish, otherwise query another sink node.
Lun el. al. in [13] proposed two decentralized algo-
rithms to compute the minimum-cost subgraphs for estab-
lishing multicast connections using network coding. Also,
they extended their work to the problem of minimum-
energy multicast in wireless networks as well as they stud-
ied directed point-to-point multicast and evaluated the case
of elastic rate demand.

Page 3

3 Wireless Sensor Networks and Fountain
Codes
In this section, we introduceour network model and pro-
vide background of Fountain codes and, in particular, one
important class of Fountain codes—LT (Luby Transform)
codes [12].
3.1Network Model
Our wireless sensor network consists of n nodes that are
uniformlydistributed at random in a region A = [L,L]2for
L > 1. The density of the network is given by
n
|A|=
where |A| is the two-dimensional Lebesgue measure (or
area) of A. Each sensor node has an identical communi-
cation radius 1; thus any two nodes can communicate with
eachotherifandonlyiftheirdistanceis less thanorequalto
1. This modelis knownas randomgeometricgraphs[7, 15].
Among these n nodes, there are k source nodes that have
information to be disseminated throughout the network for
storage. These k nodes are uniformly and independently
distributed at random among the n nodes. Usually, the frac-
tion of source nodes, i.e.,k
20%).
Note that, although we assume the nodes are uniformly
distributed at randomin a region, our algorithmsand results
do not rely on this assumption. In fact, they can be applied
for any network topology, for example, regular grids.
We assume that no node has knowledge about the lo-
cations of other nodes and no routing table is maintained;
consequently, the algorithm proposed in [5] cannot be ap-
plied. Moreover, we assume that each node has limited or
no knowledge of global information, but know its neigh-
bors. Thelimited globalinformationrefersto the total num-
bers of nodes n and sources k. Any further global informa-
tion, for example the maximal number of neighbors in the
network, is not available. Hence, the algorithms proposed
in [11, 10] are not applicable.
λ =
n
L2,
(1)
n, is not very large (e.g., 10%, or
Definition 1. (Node Degree) Consider a graph G =
(V,E), where V and E denote the set of nodes and links,
respectively. Given u,v ∈ V , we say u and v are adjacent
(or u is adjacent to v, and vice versa) if there exists a link
between u and v, i.e., (u,v) ∈ E. In this case, we also
say that u and v are neighbors. Denote by N(u) the set of
neighbors of a node u. The number of neighbors of a node
u is called the node degree of u, and denoted by dn(u), i.e.,
|N(u)| = dn(u). The mean degree of a graph G is then
given by
1
|V |
u∈G
µ =
?
dn(u),
(2)
x?1?
x?2?
x?3?
x?k?
y?1?
y?2?
y?3?
y?k?
y?n?
Figure 1. The encoding operations of Foun-
tain codes: each output is obtained by XOR-
ing d source blocks chosen uniformly and in-
dependently at random from k source inputs,
where d is drawn according to a probability
distribution Ω(d).
where |V | is the total number of nodes in G.
3.2 Fountain Codes
For k source blocks {x1,x2,...,xk} and a probabil-
ity distribution Ω(d) with 1 ≤ d ≤ k, a Fountain code
with parameters (k,Ω) is a potentially limitless stream of
output blocks {y1,y2,...}. Each output block is obtained
by XORing d randomly and independently chosen source
blocks,whered is drawnfroma specially designeddistribu-
tion Ω(d). This is illustrated in Figure 3.2. Fountain codes
are rateless, and one of their main advantage is that the en-
coding operations can be performed online. The encoding
cost is the expected number of operation sufficient for gen-
erating an output symbol, and the decoding cost is the ex-
pectednumberofoperationssufficienttorecoverthek input
blocks. Another advantage of Fountain codes, as opposed
to purely random codes is that their decoding complexity
can be made low by appropriate choice of Ω(d), with little
sacrifice in performance. The decoding of Fountain codes
can be done by message passing.
Definition 2. (Code Degree) For Fountain codes, the num-
ber of source blocks used to generate an encoded output y
is called the code degree of y, and denoted by dc(y). By
constraction, the code degree distribution Ω(d) is the prob-
ability distribution of dc(y).
3.3LT Codes
LT (Luby Transform) codes are a special class of Foun-
tain codes which uses Ideal Soliton or Robust Soliton dis-
tributions [12]. The Ideal Soliton distribution Ωis(d) for k
source blocks is given by
Ωis(i) = Pr(d = i) =





1
k,
i = 1
1
i(i − 1), i = 2,3,...,k.
(3)

Page 4

Let R = c0
0 < δ < 1. The Robust Soliton distribution for k source
blocks is defined as follows. Define
√k ln(k/δ), where c0is a suitable constant and
τ(i) =













R
ik,
Rln(R/δ)
k
i = 1,...,k
R− 1
,i =k
R,
0,i =k
R+ 1,...,k,
(4)
and let
β =
k
?
i=1
τ(i) + Ωis(i).
(5)
The Robust Soliton distribution is given by
Ωrs(i) =τ(i) + Ωis(i)
β
, for all i = 1,2,...,k
(6)
The following result provides the performance of the LT
codes with Robust Soliton distribution [12, Theorems 12
and 13].
Lemma 3 (Luby [12]). For LT codes with Robust Soliton
distribution, k original source blocks can be recovered from
any k + O(√k ln2(k/δ)) encoded output blocks with prob-
ability 1 − δ. Both encoding and decoding complexity is
O(k ln(k/δ)).
4LT-Codes
(LTCDS) Algorithms
BasedDistributedStorage
In this section, we present two LT-Codes based Dis-
tributed Storage (LTCDS) algorithms. In both algorithms,
the source packets are disseminated throughoutthe network
by a simple random walk. In the first one, called LTCDS-
I algorithm, we assume that each node in the network has
limited the global information,that is, knows the total num-
ber of sources k and the total number of nodes n. Unlike
the scheme proposed in in [10], our algorithm does not re-
quire the nodes to know the maximum degree of the graph,
which is much harder to obtain than k and n. The second
algorithm, called LTCDS-II, is a fully distributed algorithm
which does not require nodes to know any global informa-
tion. The price we pay for this benefit is extra transmissions
of the source packets to obtain estimates for n and k.
4.1With Limited Global Information—
LTCDS-I
In LTCDS-I, we assume that each node in the network
knows the values of k and n.
walks [1, 17] for each source to disseminate its information
to the whole network. At each round, each node u that has
We use simple random
packets to transmit chooses one node v amongits neighbors
uniformly independently at random, and sends the packet
to the node v. In order to avoid local-cluster effect—each
sourcepacketis trappedmostlikelybyits neighbornodes—
we let each node accept a source packet equiprobably. To
achieve this, we also need each source packet to visit each
node in the network at least once.
For a random walk on a graph, the cover time is defined
as follows [1, 17]:
Definition 4. (Cover Time) Given a graph G, let Tcover(u)
be the expected length of a random walk that starts at node
u and visits every node in G at least once. The cover time
of G is defined by
Tcover(G) = max
u∈GTcover(u).
(7)
For a simple randomwalk on a randomgeometric graph,
the following result bounds the cover time [3].
Lemma 5 (Avin and Ercal [3]). If a random geometric
graph with n nodes is a connected graph with high prob-
ability, then
Tcover(G) = Θ(nlogn).
(8)
As a result of Lemma 5, we can set a counter for each
source packet and increase the counter by one after each
forwardtransmission until the counter reaches some thresh-
old C1nlogn to guaranteethat the sourcepacket visits each
node in the network at least once. The detailed descriptions
of the initialization, encoding and storage phases (steps) of
LTCDS-I algorithm are given below:
(i) Initialization Phase:
(1) Each node u in the network draws a randomnum-
ber dc(u) according to the distribution Ωis(d)
given by (3) (or Ωrs(d) given by (6)).
source node si,i = 1,...,k generates a header
for its source packet xsiand puts its ID and a
counter c(xsi) with initial value zero into the
packet header. We set up tokens for initial and up-
date packets. We assume that a token is set to zero
for an initial packet and 1 for an update packet.
Each
packetsi= (IDsi,xsi,c(xsi))
(2) Each source node si sends out its own source
packet xsito another node u which is chosen uni-
formly at random among all its neighbors N(si).
(3) The chosen node u accepts this source packetsi
with probabilitydc(u)
k
and updates its storage as
y+
u= y−
u⊕ xsi,
(9)
where y−
u stores before and after the updating, respec-
tively, and ⊕ represents XOR operation. No mat-
ter whether the source packet is accepted or not,
uand y+
udenote the packet that the node

Page 5

the node u puts it into its forward queue and set
the counter of xsias
c(xsi) = 1.
(10)
(ii) Encoding Phase:
(1) In each round, when a node u receives at least
one source packet before the current round, u for-
wards the head-of-line (HOL) packet x in its for-
ward queue to one of its neighbor v, chosen uni-
formly at random among all its neighbors N(u).
(2) Dependingonhowmanytimesxhas visitedv, the
node v makes its decisions:
• If it is the first time that x visits v, thenthe node
v accepts this source packet with probabilityd
and updates its storage as
k
y+
v= y−
v⊕ x.
(11)
• If x has visited v before and c(x) < C1nlogn
where C1is a system parameter, then the node
v accepts this source packet with probability 0.
• No matter x is accepted or not, the node v
puts it into its forward queue and increases the
counter of x by one:
c(x) = c(x) + 1.
(12)
• If x has visited v before and c(x) ≥ C1nlogn
then the node v discards the packet x forever.
(iii) Storage Phase:
When a node u makes its decisions for all the source
packets xs1,xs2,...,xsk, i.e., all these packets have
visited the node u at least once, the node u finishes
its encoding process by declaring the current yuto be
its storage packet.
The pseudo-code of these steps is given in LTCDS-I Al-
gorithm 1.
The following theorem establishes the code degree dis-
tribution of each storage node induced by the LTCDS-I al-
gorithm.
Theorem 6. When a sensor network with n nodes and k
sources finishes the storage phase of the LTCDS-I algo-
rithm, the code degree distribution of each storage node u
is given by
Pr(˜dc(u) = i)
=
k
?
dc(u)=1
?k
i
??dc(u)
k
?i?
1 −dc(u)
k
?k−i
Ω′(dc(u)), (13)
where dc(u) is given in the initialization phase of the
LTCDS-I algorithm from distribution Ω′(d) (i.e., Ωis(d) or
Ωrs(d)), and˜dc(u) is the code degree of the node u result-
ing from the algorithm.
Input: number of nodes n, number of sources k,
source packets xsi,i = 1,2,...,k and a
positive constant C1
Output: storage packets yi,i = 1,2,...,n
foreach node u = 1 : n do
Generate dc(u) according to Ωis(d) (or Ωrs(d));
end
foreach source node si,i = 1 : k do
Generate header of xsiand token = 0;
c(xsi) = 0;
Choose u ∈ N(si) uniformly at random, send xsi
to u;
coin = rand(1);
if coin ≤dc(u)
Put xsiinto u’s forward queue;
c(xsi) = c(xsi) + 1;
end
while source packets remaining do
foreach node u receives packets before current
round do
Choose v ∈ N(u) uniformly at random;
Send HOL packet xsiin u’s forward queue to
v;
if v receives xsifor the first time then
coin = rand(1);
if coin ≤
yv= yv⊕ xsi;
Put xsiinto v’s forward queue;
c(xsi) = c(xsi) + 1
end
else if c(xsi) < C1nlogn then
Put xsiinto v’s forward queue;
c(xsi) = c(xsi) + 1;
else
Discard xsi;
end
end
end
k
then yu= yu⊕ xsi;
dc(v)
k
then
Algorithm 1: LTCDS-I Algorithm: LT-Codes based Dis-
tributed Storage Algorithm for a wireless sensor network
(WSN) with limited global information, i.e., values of n
and k are knownat every node. It consists of three phases:
initialization, encoding and storage phases. The algorithm
can also be deployed in a WSN after estimating values of
n an k, as shown in LTCDS-II algorithm.
Proof. For each node u, dc(u) is drawn from a distribution
Ω′(d) (i.e., Ωis(d) or Ωrs(d)). Given dc(u), the node u
accepts each source packet with probabilitydc(u)
dently of each other and dc(u). Thus, the number of source
packets that the node u accepts follows a Binomial distribu-
k
indepen-