MDS-Coded Distributed Caching for Low Delay Wireless Content Delivery

0.4 MB·

by  Amina Piemontese

1
MDS-Coded Distributed Caching for
Low Delay Wireless Content Delivery
Amina Piemontese, Member, IEEE, and Alexandre Graell i Amat, Senior Member, IEEE
Abstract
7
We investigate the use of maximum distance separable (MDS) codes to cache popular content to reduce the
1
0
download delay of wireless content delivery. In particular, we consider a cellular system where devices roam in an
2

n
out of a cell according to a Poisson random process. Popular content is cached in a limited number of the mobile
a
J
devicesusinganMDScodeandcanbedownloadedfromthemobiledevicesusingdevice-to-devicecommunication.
5

] We derive an analytical expression for the delay incurred in downloading content from the wireless network and
T
I show that distributed caching using MDS codes can dramatically reduce the download delay with respect to the
.
s
c
scenario where content is always downloaded from the base station and to the case of uncoded distributed caching.
[

1
v
1
9
4
1 I. INTRODUCTION
0
.
1
The proliferation of mobile devices and the surge of a myriad of multimedia applications has resulted
0
7
1 in an exponential growth of the mobile data traffic. In this context, wireless caching has emerged as a
:
v
i powerful technique to overcome the backhaul bottleneck, by reducing the backhaul rate and the delay in
X
r
a retrieving content from the network. The key idea is to store popular content closer to the end users. In
The authors are with the Department of Signals and Systems, Chalmers University of Technology, 412 96 Gothenburg, Sweden (e-mail:
{aminap,alexandre.graell}@chalmers.se.
Amina Piemontese is supported by a Marie Curie fellowship (contract 658785-DISC-H2020-MSCA-IF-2014). This work was also was
partially funded by the Swedish Research Council under grant #2011-5961.
The paper was presented in part at the International Symposium on Turbo Codes & Iterative Information Processing, Brest, France, Sep.
2016
2
[1], a novel system architecture named femtocaching was proposed. It consists of deploying a number of
small base stations (BSs) with large storage capacity, in which content is stored during periods of offpeak
traffic. The mobile users can download content from the small BSs, which results in a higher throughput
per user. In [2], it was proposed to store content directly in the mobile devices. Users can then retrieve
content from neighboring devices using device-to-device (D2D) communication or, alternatively, from the
serving BS.
In both scenarios, content may be stored using an erasure correcting code, which brings gains with
respect to uncoded caching [3]–[6]. The use of erasure correcting codes establishes an interesting link
between distributed caching for content delivery and distributed storage (DS) for reliable data storage. The
key difference is that in the wireless network scenario, data can be downloaded from the storage nodes
(the small BSs or the mobile devices) but also from a serving macro BS, which has always the content
available. Therefore, the reliability requirements in DS for reliable data storage can be relaxed. In [5],
the placement of content encoded using a maximum distance separable (MDS) code to small BSs was
investigated and it was shown that a careful placement allows to significantly reduce the backhaul rate.
In [3], for the scenario where content is stored directly in the mobile devices, the repairing of the lost
data when a device storing data leaves the network was considered. Assuming instantaneous repair, the
communication cost of data download and repair was investigated. In [4], [6], a repair scheduling where
repair is performed periodically was introduced and analytical expressions for the overall communication
cost of content download and data repair as a function of the repair interval were derived. Using these
expressions, the overall communication cost entailed by storing content using MDS codes, regenerating
codes [7], and locally repairable codes [8] was evaluated in [6] and it was shown that storing content
using erasure correcting code can reduce the overall communication cost with respect to the scenario
where content is downloaded solely from the BS.
In this paper, we consider a similar cellular network scenario as the one in [3], [6], where content is
stored in a number of mobile devices using an erasure correcting code. Mobile devices roam in an out of
a cell according to a Poisson random process. However, as opposed to [3], [6], where the download of
3
a single file is considered, here we consider that users may request files, of different popularity, from a
library of files. Our focus is on the delay of retrieving content from the network, which was not considered
in [3], [6]. We derive analytical expressions for the download delay if content is stored in the mobile
devices using MDS codes and show that MDS-coded distributed caching can significantly reduce the
download delay with respect to the case where content is solely downloaded from the BS and the case
where uncoded caching is used. The download delay of a single file was analyzed in [9].
The remainder of the paper is organized as follows. The system model is introduced in Section II. The
average download delay incurred when MDS-coded distributed caching is used is analyzed in Sections III
and Section IV. Section V presents and discusses numerical results and finally some conclusions are drawn
in Section VI.
Notation. The probability density function (pdf) of a random variable X is denoted by f (·) and the
X
expectation with respect to X is denoted by E {·}. Probability is denoted by Pr{·} and 1 represents
X i
the all-ones vector of length i. We denote by π (ρ) the stationary distribution of an M/M/∞ queueing
m
system described by a Poisson birth-death process with arrival rate α and departure rate per node δ, which
is given by
ρm
π (ρ) = e ρ,
m m! −
where ρ = α/δ.
II. SYSTEM MODEL
We consider a single cell in a cellular network where M mobile devices, referred to as nodes, request
files, each of size B bits, from a library of Z files. The files have different popularities and accordingly
have a given probability to be requested. Depending on the placement strategy, some files are encoded and
stored into n ≤ M mobile devices, referred to as storage nodes. For ease of language, the set of storage
nodes is referred to as the DS network and nodes not storing any content are referred to as regular nodes.
A copy of each encoded file is also available at the BS serving the cell. A node requesting a file attempts
to retrieve it from the storage nodes using D2D communication, and, if the file cannot be completely
retrieved from the DS network, the BS assists in providing the missing data. In order to increase the
4
system efficiency, we allow multiple D2D communications to coexist if they are sufficiently far apart in
space. Therefore, we divide the cell in C virtual clusters and assume that the size of the cluster and the
transmit power are properly chosen such that only one D2D communication can be established between
any two nodes in the cluster and the interference across different clusters can be neglected. A similar
model is considered in [2], [10].
Data allocation and coding strategy. We adopt a deterministic allocation strategy, where the F ≤ Z
most popular files are cached in a distributed fashion in n storage nodes in the cell, according to the
storage capacity of the devices. These files are partitioned into k packets, called symbols, of B/k bits
each and are encoded into n coded symbols using an (n,k) MDS erasure correcting code of rate r = k/n.
We use the same code for every file in order to simplify the analysis. We assume that each storage node
stores a single symbol for each of the F most popular files. Overall, nF symbols are stored in n storage
nodes and no two storage nodes store the same symbol. We model the popularity of the files in the library
using the time-invariant Zipf distribution [11].1 Accordingly, the probability that the ith file is requested
is
1/iσ
z = , 1 ≤ i ≤ Z, (1)
i (cid:80)Z 1/jσ
j=1
where parameter σ regulates the relative popularity of the files. In the following, the set of F files stored
in the cache of the mobile devices will be referred to as the DS library.
We assume that the mobile devices are free to move inside the cell. We consider a uniform spatial
distribution of the nodes in the cell, and hence there are M = M/C devices per cluster on average and
c
among them n = n/C storage nodes. We focus on a single cluster in isolation, and assume that the
c
devices roam in and out of it. The arrival, departure and request model of the nodes are borrowed from
[6]. The considered scenario is shown in Fig. 1.
Arrival-departure model. We assume that nodes arrive to the cluster according to a Poisson random
process with exponential independent, identically distributed (i.i.d.) random inter-arrival times T with pdf
a
f (t) = M λe Mcλt, λ ≥ 0,t ≥ 0, (2)
Ta c −
1The popularity of the files in mobile data traffic does not change very rapidly, i.e., it can be considered constant during the day.
5
where M λ is the expected arrival rate and t is time, measured in time units (t.u.). The nodes stay in the
c
cluster for an i.i.d. exponential random lifetime T with pdf
(cid:96)
f (t) = µe µt, µ ≥ 0,t ≥ 0, (3)
T(cid:96) −
where µ is the expected departure rate per node. We assume that µ = λ, which implies that the expected
number of nodes in the cluster is M . This model corresponds to an M/M/∞ queuing model and the
c
probability that there are i nodes in the cluster is π (M ). The arrival of storage nodes to the cluster can
i c
also be described as a Poisson random process. In particular, the inter-arrival times T of the set of storage
s
nodes has pdf
f (t) = n λe ncλt, λ ≥ 0,t ≥ 0.
Ta c −
The related lifetime is described by (3) and the probability that there are i storage nodes in the cluster is
π (n ).2
i c
DS network update. We assume that the nodes storing content that arrive to the cluster from neighboring
clusters are not immediately available for download, but the BS serving the cell keeps track of them and
periodically updates and broadcasts to all mobile devices the list of storage nodes in the cell every ∆ t.u..
In the sequel, parameter ∆ is referred to as the update interval and the set of storage nodes in the list
broadcasted by the BS as the DS list.
Data delivery. Nodes request the file at random times with i.i.d. random inter-request time T with pdf
r
f (t) = ωe ωt, ω ≥ 0,t ≥ 0, (4)
Tr −
where ω is the expected request rate per node. We focus on the download process. The node that requests
a file attempts to retrieve it from the DS network using D2D communication. Thanks to the MDS property,
2The Poisson model is largely used in the case of uniform mobility and its popularity is also due to its tractability. However, we would
liketoremarkthatwhileitisabletocapturethemobilityinonecluster,thismodeldoesnotguaranteethatthetotalnumberofstoragenodes
inthecellisconstantandequalton.Moreprecisely,theonlyguaranteeisthatthereareonaveragen storagenodespercluster,butthere
c
are no constraints on their instantaneous number, which can even exceed n. On the other hand, the probability of having a high number of
storagedevicesinoneclusterisgenerallyverylow.Forn =9,wehaveπ (n )=3·10−3,π (n )=6.6·10−7 andπ (n )=4·10−48.
c 18 c 27 c 91 c
The same consideration holds for the total number of mobile devices.
6
t
bs
µ
(Mc nc)λ
−
t
d
ncλ µ
Figure 1. An example of cluster where nodes roam in and out according to a Poisson random process: we have on average M mobile
c
devices, and n storage nodes among them (red circles), caching one different coded symbol for each of the most popular files. A device
c
requesting a file (pink circle), must collect k symbols. It attempts to recover them by using the DS network if the requesting file is stored
in the devices. It uses the BS to collect the symbols that it is not able to download from the devices. The download of a symbol from a
storage node takes t t.u., and from the BS t t.u..
d bs
an encoded file can be reconstructed by accessing any k encoded symbols. If the file cannot be completely
retrieved from the DS network, the BS assists in providing the missing coded symbols. The download of a
codedsymbolfromastoragenodeincurst t.u.andfromtheBSt t.u..Weassumethatt (cid:29) t duetothe
d bs bs d
congestion of the BS-to-node link and the fact that D2D communication occurs over a better channel due
to the reduced distance between the involved nodes. We further assume that only one D2D link at a time
can be established, and that the D2D communication does not interfere with the communication between
the BS and the nodes. We say that the D2D network is idle if there is no active D2D communication in
the cluster. If the D2D network is not idle when one node requests the file, the whole file is downloaded
from the BS. Moreover, to simplify the analysis, we assume that multiple BS-to-node links can coexist.
III. FILE AVERAGE DOWNLOAD DELAY
We investigate the average time that is required to retrieve one file from the wireless network, referred
to as the download delay. If a requested file is stored in the DS library, the requesting node attempts to
retrieve it from the DS network using D2D communication, otherwise the file is entirely downloaded from
the BS. Therefore, we introduce the binary random variable (RV) H ∈ {0,1} which describes the hitting
7
of the DS cache, i.e., H = 1 if a file of the DS library is requested and H = 0 otherwise. Moreover, the
D2D network can be used only if it is idle, i.e., if there are no active D2D communications. Accordingly,
we introduce the binary RV I ∈ {0,1} that describes the status of the D2D network. I = 1 if the network
is idle and I = 0 otherwise. If the D2D network is idle, the requesting node tries to collect the necessary
coded symbols from the nodes of the DS list provided by the BS using D2D communication. If the
requesting node is a storage node of the DS list, it needs to download k−1 symbols, otherwise k symbols
must be downloaded. We thus introduce the binary RV R ∈ {0,1}, which represents the type of request,
i.e., R = 1 for requests originating from a node that belongs to the DS list and R = 0 for the other
requests. The download from the storage nodes can be either fully successful or partially accomplished,
in which case the requesting node turns to the BS to recover the missing symbols. On the other hand, if
the D2D network is not idle and the requested file is stored in the DS library, the node downloads k or
k −1 symbols from the BS, depending on the type of node.
From the discussion above, the average file download delay, T , may be formalized as
dw
Proposition 1. The average file download for the cellular network described in Section II where the F
most popular files are stored in the mobile devices using an (n,k) MDS code is
(cid:16) (cid:17)
T =Pr{H = 0}kt +Pr{I = 1}Pr{H = 1} T +(k −Pr{R = 1}−η)t
dw bs η bs
+Pr{I = 0}Pr{H = 1}(k −Pr{R = 1})t , (5)
bs
where η is the average number of coded symbols downloaded per request using D2D communication and
T , referred to as the average D2D download delay, is the corresponding delay.
η
The computation of η, T and Pr{R = 1} is addressed in Section IV. The probability of hitting the
η
cache can be expressed as
F
(cid:88)
Pr{H = 1} = z ,
i
i=1
where the probabilities z are given in (1). It follows that Pr{H = 1} = 1 if F = Z.
i
The next step is the computation of the probability that the D2D network is idle. Let I((cid:96)) be the status
8
of the network at the time of the (cid:96)th request. It follows
L
1 (cid:88)
Pr{I = 1} = lim Pr{I((cid:96)) = 1}. (6)
L L
→∞ (cid:96)=1
In order to compute Pr{I((cid:96)) = 1}, we introduce the RV W(j) that denotes the time instant of the jth
request. Also, let T(j) be the time during which the D2D network is occupied by the jth request. The
D2D network is idle at the time of the (cid:96)th request if none of the previous requests is still using D2D
communication. Therefore, Pr{I(1) = 1} = 1 and
(cid:89)
Pr{I((cid:96)) = 1}= Pr{W((cid:96))>W((cid:96) i)+T((cid:96) i)}, (cid:96) > 1. (7)
− −
i<(cid:96)
Assuming that if the D2D network is not idle at time W((cid:96)) is because of the ((cid:96)−1)th request, the product
in (7) reduces to the term involving the ((cid:96)−1)th request only, i.e.,
Pr{I((cid:96)) = 1} (cid:39) Pr{W((cid:96)) > W((cid:96) 1) +T((cid:96) 1)} (8)
− −
(cid:90)
= ∞Pr{W((cid:96)) > W((cid:96) 1) +t}f (t)dt.
− T((cid:96)−1)
0
Since the requests are i.i.d. with inter-request time distributed as in (4) and on average there are M nodes
c
in the cluster, we can compute
Pr{W((cid:96)) > W((cid:96) 1) +t} = e ωMct, t (cid:62) 0, (cid:96) > 1,
− −
and (8) can be written as
Pr{I((cid:96)) = 1} (cid:39) E {e ωMcT((cid:96)−1)}, (cid:96) > 1,
T((cid:96)−1) −
If ωT((cid:96) 1) (cid:28) 1,
−
e ωMcT((cid:96)−1) (cid:39) 1−ωM T((cid:96) 1) (9)
− c −
and
Pr{I((cid:96)) = 1} (cid:39) E {e ωMcT((cid:96)−1)}
T((cid:96)−1) −
(cid:39) E {1−ωM T((cid:96) 1)}
T((cid:96)−1) c −
= 1−ωM Pr{I((cid:96) 1) = 1}Pr{H = 1}T . (10)
c − η
9
In (10), we used the fact that the probability of hitting the cache and the average D2D download delay
are independent of the request index (if (cid:96) is sufficiently large), as it is proven in Lemma 1 in Section IV.
Substituting (10) in (6) and after some simple calculations, we obtain
1
Pr{I = 1} (cid:39) . (11)
1+ωM Pr{H = 1}T
c η
IV. DOWNLOAD FROM STORAGE NODES
In this section, we consider the computation of the average D2D download delay T and the average
η
number of coded symbols η downloaded per request using D2D communication. We assume that a node
cannot download in parallel from multiple nodes, but it serially tries to download the coded file symbols
from the nodes in the DS list. When a node requests the file, if the D2D network is idle and the requested
file belongs to the DS library, it randomly chooses one of the storage nodes from the list supplied by the
BS. After each downloaded symbol, the requesting node randomly chooses another storage node from the
DS list and still alive.3 We assume that a requesting node that has collected fewer than the k symbols
necessary to reconstruct the file turns to the BS when all the reference storage nodes left or when the
download of a symbol fails, even if other storage nodes are available. To simplify the analysis, we assume
that both cases (the failed symbol download and the absence of storage nodes) incur t t.u., even if the
d
node could contact the BS earlier. We also assume that the download from the D2D network fails if the
requesting node itself leaves the cluster before collecting k symbols. In this case, the download is also
completed from the BS.
To derive the average D2D download delay, we introduce three RVs describing the number of nodes
of different type that are present in the cluster at the instant of a request: the number of storage nodes
of the DS list, the total number of storage nodes (belonging or not to the list, the latter corresponding to
the storage nodes that arrive to the cluster after the DS list update and that have not left the cluster at
the time of the request), and the number of regular nodes. In particular, we denote by X ∈ {0,...,∞}
1
the RV that describes the number of storage nodes of the DS list when a request arrives. We describe
3The requesting node uses the storage nodes alive at the moment of its request even if, during the download process, new storage nodes
are included in the DS list after the periodic restoration.
10
by the RVs Q ∈ {0,...,∞} and V ∈ {0,...,∞} the total number of storage nodes and the number of
regular nodes at the instant of a request, respectively. Moreover, we denote by Y ∈ {0,...,∞} the RV
that represents the total number of storage nodes (belonging or not to the DS list) at the beginning of
the update interval of length ∆. In the following three lemmas, we give a probabilistic description of the
above RVs.
Lemma 1. The probability that there are x ≥ 0 storage nodes of the DS list at the time of a request is
(cid:80) (cid:80)
π (n ) (1−e mω∆)π (M −n )Pr{X = x|Y = y}
Pr{X1 = x} = ∞y=0 y c ∞m=y (cid:80) −(1−e mm−ωy∆)πc (Mc) 1 , (12)
∞m=1 − m c
where Pr{X = x|Y = y} is the probability that X is equal to x, given that y ≥ 0 storage nodes are in
1 1
the cluster at the beginning of the update interval of length ∆, and is
y y y y
Pr{X = x|Y = y} = 1 (cid:88) 1−pi(cid:48) (cid:89) j − 1 (cid:88) 1−pi(cid:48) (cid:89) j , (13)
1 ∆ µ j −i ∆ µ j −i
i(cid:48)=x i(cid:48) j=x (cid:48) i(cid:48)=x+1 i(cid:48) j=x+1 (cid:48)
j=i(cid:48) j=i(cid:48)
(cid:54) (cid:54)
where µi(cid:48) = i(cid:48)µ and pi(cid:48) = e−µi(cid:48)∆.
Proof: The proof is given in Appendix A.
Lemma 2. The probability that there are q ≥ 0 storage nodes in the cluster at the time of a request is
given by
(cid:80)
(1−e mω∆)π (M −n )
Pr{Q = q} = ∞m(cid:80)=q (1−−e mω∆m)−πq (Mc ) c πq(nc). (14)
∞m=1 − m c
Proof: The proof follows the same lines as the proof of Lemma 1.
Lemma 3. The probability that there are v ≥ 0 regular nodes in the cluster at the time of a request is
given by
(cid:80)
(1−e mω∆)π (n )
Pr{V = v} = (cid:80)∞m=v (1−e− mω∆)πm−(vM c) πv(Mc −nc). (15)
∞m=1 − m c
Proof: The proof follows the same lines as the proof of Lemma 1.
Based on the above lemmas, we can compute the probability that the request originates from a storage
node of the DS list and the probability of having a given number of storage nodes in the DS list at the
time of the request conditioned to the type of request.