Proactive Edge Computing in Latency-Constrained Fog Networks

TL;DR

This paper proposes a proactive caching and task distribution scheme in fog networks that minimizes latency and ensures reliability, achieving up to 91% latency reduction compared to baseline methods.

Contribution

It introduces a clustering-based proactive caching strategy and a task distribution matching game for fog networks under latency and reliability constraints.

Findings

Achieves up to 91% reduction in computing latency.

Guarantees reliable computations with bounded latency.

Effectively minimizes delay through proactive caching and task distribution.

Abstract

In this paper, the fundamental problem of distribution and proactive caching of computing tasks in fog networks is studied under latency and reliability constraints. In the proposed scenario, computing can be executed either locally at the user device or offloaded to an edge cloudlet. Moreover, cloudlets exploit both their computing and storage capabilities by proactively caching popular task computation results to minimize computing latency. To this end, a clustering method to group spatially proximate user devices with mutual task popularity interests and their serving cloudlets is proposed. Then, cloudlets can proactively cache the popular tasks' computations of their cluster members to minimize computing latency. Additionally, the problem of distributing tasks to cloudlets is formulated as a matching game in which a cost function of computing delay is minimized under latency and reliability constraints. Simulation results show that the proposed scheme guarantees reliable computations with bounded latency and achieves up to 91% decrease in computing latency as compared to baseline schemes.

Equations

$$D_{ua}^{\text{l}}(t)=\frac{\kappa L_a}{c_{\text{local}}}+W_{ua}^{\text{l}}(t)+{\text{τ}}_{\text{LP}},$$

$$D_{ea}^{\textrm{f}}(t)=\biggl{(}\frac{\kappa L_{a}}{c_{e}}+\frac{L_{a}}{r_{ue}(t)}+W_{ea}^{\textrm{f}}(t)\biggr{)}(1-y_{ea}(t))+\text{$\tau$}_{\textrm{EP}},$$

$$D_{a}(t)=x_{ea}(t)D_{ea}^{\textrm{f}}(t)+\biggl{(}1-\sum_{e\in\mathcal{E}}x_{ea}(t)\biggr{)}D_{ua}^{\textrm{l}}(t),$$

$$\underset{\mathbf{X},\mathbf{Y}}{\min }$$

$$\mathrm{Pr}(D_{ea}^{\text{f}}(t)\ge D_{\text{th}})\le ϵ,\forall e\in \mathcal{E},$$

$$\sum _{e\in \mathcal{E}}{x}_{ea}(t)\le 1,\forall u\in \mathcal{U},$$

$$\sum _{a\in Q_e}{x}_{ea}(t)\le 1,\forall e\in \mathcal{E},$$

$$\sum _{a\in \mathcal{A}}{y}_{ea}(t)\le s_e,\forall e\in \mathcal{E},$$

$$\mathbb{E}\biggl{\{}\frac{\kappa L_{a}}{c_{e}}+\frac{L_{a}}{r_{ue}(t)}+W_{ea}^{\textrm{f}}(t)+\text{$\tau$}_{\textrm{EP}}\biggr{\}}\leq D_{\textrm{th}}\epsilon,$$

$$\mathbb{E}\biggl{\{}\frac{L_{a}}{r_{ue}(t)}\biggr{\}}\leq D_{\textrm{th}}\epsilon-\mathbb{E}\biggl{\{}\sum_{a_{i}\in Q_{e}}\frac{L_{a_{i}}^{\prime}(t)}{r_{ie}(t)}\biggr{\}}-\frac{\kappa L_{a}}{c_{e}}-\text{$\tau$}_{\textrm{EP}},$$

$$\frac{L_a}{{\bar{r}}_{ue}(t)}\le D_{\text{th}}ϵ-\frac{\kappa L_a}{c_e}-\sum _{a_i\in Q_e}\frac{L_{a_i}^{\prime }(t)}{{\bar{r}}_{ie}(t)}-{\text{τ}}_{\text{EP}}.$$

$${\bar{r}}_{ue}(t)=\nu (t)r_{ue}(t-1)+(1-\nu (t)){\bar{r}}_{ue}(t-1).$$

$$d_{ij}=\exp \left(\frac{-\parallel {\mathbf{v}}_i-{\mathbf{v}}_j{\parallel }^2}{2{\sigma }_d^2}\right),$$

$$p_{ij}=\frac{{\mathbf{n}}_i.{\mathbf{n}}_j}{\parallel {\mathbf{n}}_i\parallel \parallel {\mathbf{n}}_j\parallel }.$$

$$\mathbf{S}=\theta {\mathbf{S}}_d+(1-\theta ){\mathbf{S}}_p,$$

$$e{\succ }_u{e}^{\prime }\iff D_{ea}^{\text{f}}(t)<D_{e^{\prime }a}^{\text{f}}(t),$$

$$u{\succ }_{u}e\iff D_{ua}^{\text{l}}(t)<D_{ea}^{\text{f}}(t).$$

$${\Phi }_{eu}(t)=D_{th}ϵ-\frac{k_a{L}_a}{c_e}-\sum _{a_i\in Q_e}\frac{L_{a_i}^{\prime }(t)}{{\bar{r}}_{ie}(t)}-{\text{τ}}_{\text{EP}}-\frac{L_a}{{\bar{r}}_{ue}(t)}.$$

$$u{\succ }_e{u}^{\prime }\iff {\Phi }_{eu}(t)>{\Phi }_{e{u}^{\prime }}(t),$$

$$e{\succ }_{e}u\iff {\Phi }_{eu}(t)<0,$$

Full text

††publicationid: pubid: 978–1–5386–3873–6/17/$31.00 © 2017 IEEE

I Introduction

The emergence of the Internet of things (IoT) and machine-to-machine communication is paving the way for a seamless connectivity of a massive number of resource-limited devices and sensors [1]. The unprecedented amount of IoT data communication and computation requirements impose stringent requirements in end-to-end latency, mandating ultra-reliable and low-latency communications (URLLC). However, the finite computation capabilities of end-user devices challenge the possibility of coping with the stringent computing and processing latency requirements of IoT networks. Therefore, mobile cloud computing (MCC) services have been recently proposed to allow end-users to offload their resource consuming tasks to remote cloud centers. However, despite having high computational resources, MCC solutions are inefficient in handling latency-critical computing services due to the high propagation delays between the end-user device and the cloud data center.

Recently, the idea of fog computing has been introduced [2] to bring computing resources closer to where tasks are requested. In order to minimize computing latency in fog networks, smarter communication and computing resource utilization schemes are needed [3]. A centralized joint communication and computation resource allocation scheme is proposed in [4]. The power-delay tradeoff in centralized mobile edge computing (MEC) systems is discussed in [5] using tools from stochastic optimization. However, these works rely on centralized solutions in which the MEC network has information about all users requests and channel-state information (CSI). Game-theoretic solutions are studied in [6] to design decentralized computing offloading schemes in cases of homogeneous and heterogeneous users. Recently, an online secretary framework for fog network formation is proposed in [7] under uncertainty on the arrival process of fog nodes.

While interesting, the vast majority of the literature in fog networking is based on the reactive computing paradigm in which task computing starts only after the task data is offloaded to the fog node [3]. Moreover, prior art has not explicitly accounted for stringent latency and reliability constraints in fog networks. Due to the distributed nature of these networks, having computing resources closer to the network edge allows for providing personalized type of computing services to end-users [3]. Clearly, harnessing the correlation between end-user requests motivates the need for proactive computing to minimize computing latency. For example, for augmented reality (AR) services provided in a museum, proactively computing popular AR services of visitors can aid in minimizing computational latency [8]. Using proactive computing, the fog network can keep track of the popularity patterns of user tasks and cache their computing results in advance. This eliminates the need to request the task data multiple times thus reducing the burden on the task offloading transmissions [3]. A possible first step towards proactive computing is the idea of task data prefetching [9], in which part of the upcoming task data is predicted and prefetched during the computing of the current one such that the fetching time is minimized.

While the idea of proactive networks has been recently studied in the context of wireless content caching, such as [10] and [11], none of these works investigate the problem of proactive caching of computing tasks. In contrast to content caching, computing caching poses new challenges. First, while in content caching, popular contents are prefetched from the core network during off-peak times to alleviate the burden on the backhaul links, computing caching decreases the load on the access link by providing computing results to end-user nodes (UNs) without the need to prefetch their task data beforehand. Second, computing tasks can be of diverse types and depend on the computing environment, while some of the content is cacheable for reuse by other devices, personal computing data is not cacheable, and must often be computed in real time. Finally, due to the nature of IoT networks, with large number of deployed servers and low density of UNs per server [12], it is not practical to build popularity patterns locally at each server. Instead, studying popularity distributions over larger sets of servers can provide a broader view on the popularity patterns of computing tasks.

The main contribution of this paper is to investigate the problem of edge computing and proactive edge caching in fog computing networks. We exploit both computing and storage resources to minimize computing latency via joint task offloading and proactive caching of popular and cacheable computing tasks. A cacheable task has a computing result that can be reused by several other devices. Moreover, we impose constraints on computing latency and reliability so as to ensure computing delay bounds with high levels of reliability. In the proposed framework, clusters of UNs and their serving edge computing nodes (cloudlets) are formed based on spatial proximity and mutual interests in popular tasks. Accordingly, cloudlets proactively cache computed results of popular tasks in their clusters thereby ensuring minimal latency. Moreover, the problem of task distribution to cloudlets is modeled as a matching game between cloudlets and UNs. To this end, an efficient distributed matching algorithm is proposed to reach a stable matching of UN requests to cloudlets or to their local device such that the minimal task computing delay is incurred and a reliable service latency is guaranteed. Simulation results show that the proposed framework can guarantee reliable computations with bounded latency and achieve up to $91\%$ decrease in computing latency as compared to baseline schemes.

The rest of this paper is organized as follows. Section II describes the system model and problem formulation. The proposed clustering scheme as well as the joint caching and matching scheme are studied in Section III. The performance of the proposed framework is analyzed in Section IV. Finally, Section V concludes the paper.

II System Model

Consider a fog network that consists of a set $\mathcal{E}$ of $E$ cloudlets, each of which having a CPU computing and storage capability of $c_{e}$ and $s_{e}$, respectively, and a set $\mathcal{U}$ of $U$ UNs that are distributed uniformly over the network area. Cloudlets share the same frequency channel and operate in time-division-duplex (TDD). In our model, we focus on the uplink transmission. UNs have computing tasks that arrive following a Poisson process with mean $\lambda_{u}$. UNs are interested in a set $\mathcal{A}$ of $A$ tasks. Each task has a required CPU cycles of $\kappa$ per bit of task data, and the task data size follows an exponential distribution of mean $L_{a}$. UNs can offload their computing tasks to any cloudlet within their coverage, where coverage is decided based on a threshold path loss value111Path loss is used as a coverage metric such that UN’s cloudlet list does not change frequently due to wireless channel dynamics.. Task data must be offloaded to the cloudlet prior to computation. To minimize the task data offloading delay, cloudlets proactively cache the computed results of the most popular cacheable tasks. We assume that a subset $\mathcal{A}_{c}\subset\mathcal{A}$ of the tasks are cacheable and another subset $\mathcal{A}_{nc}\subset\mathcal{A}$ is non-cacheable such that $A_{c}\cup\mathcal{A}_{nc}=\mathcal{A}$. An illustration of the studied fog network model is shown in Fig. 1.

II-A Computing Model

The computation of each task $a\in\mathcal{A}$ by UN $u$ can be either performed locally or offloaded to a cloudlet. The total local computing time is:

[TABLE]

where $W_{ua}^{\textrm{l}}(t)$ is the queuing delay of task $a$ in the local queue of UN $u$ at time $t$, $c_{\textrm{local}}$ is the local computing capability in cycles/second, and \text{\tau}_{\textrm{LP}} is the local processing delay.

Each task $a$ requested by user $u$ and offloaded to the cloudlet $e$ experiences a total computing delay that consists of the task data transmission time, cloudlet computing time, cloudlet queuing time, and processing time, as follows:

[TABLE]

where r_{ue}=\textrm{BW}\log_{2}\Bigl{(}1+P_{u}h_{ue}/(N_{o}+I_{e})\Bigr{)} is the uplink data rate222BW is the channel bandwidth, $P_{u}$ is the transmit power of UN $u$, $h_{ue}$ is the channel gain between UN $u$ and cloudlet $e$, $I_{e}$ is the interfering power from other UNs, and $N_{o}$ is the noise power. from UN $u$ to the cloudlet $e$, $W_{ea}^{f}(t)$ is the waiting time of task $a$ due to the previous computing tasks in the queue $Q_{e}$ of cloudlet $e$, $y_{ea}(t)$ is a binary variable that equals $1$ when the computation result of task $a$ is cached in cloudlet $e$, and \text{\tau}_{\textrm{EP}} is the cloudlet latency which accounts for the downlink transmission of computed data and the cloudlet processing latency. Consequently. the delay incurred by the computation of a given task $a$ will be:

[TABLE]

where $x_{ea}$ is a binary variable that equals $1$ if task $a$ is distributed to cloudlet $e$.

Similar to other works [9], we assume that the latency due to downlink transmission of computed data is negligible compared to the uplink task data offloading time and computing time, and, hence, it is not accounted for in the optimization problem. This assumption is due to the typically small size of computed data and the relatively high transmission power of cloudlet compared to end-user devices.

Our objective is to minimize the total task computing latency under reliability constraints, by efficiently distributing and proactively caching the results of computing tasks. The UN task distribution to cloudlets and task caching matrices are expressed as $\boldsymbol{X}=[x_{ea}]$ and $\boldsymbol{Y}=[y_{ea}]$, respectively. Reliability is modeled as a probabilistic constraint on the maximum offloaded computing delay. This optimization problem is:

[TABLE]

[TABLE]

where (4b) is a probabilistic delay constraint that ensures the latency is bounded by a threshold value $D_{\textrm{th}}$ with a probability $1-\epsilon$. Constraints (4c) and (4d) ensure the one-to-one correspondence of distributing new requests to cloudlets. (4e) limits the number of cached tasks to a maximum of $s_{e}$. The above problem is a combinatorial problem with a non-convex cost function and probabilistic constraints, for which finding an optimal solution is computationally complex [13]. The non-convexity is due to the service rate term in the delay equation which is function of the interference from other offloading UNs. To make the problem tractable, we use the Markov’s inequality to convert the probabilistic constraint in (4b) to a linear constraint [13] expressed as $\mathbb{E}\{D_{ea}^{\textrm{f}}(t)\}\leq D_{\textrm{th}}\epsilon,$ where $\mathbb{E}\{.\}$ denotes the expectation over time. Since the delay of computing a cached task is very small, we are interested in keeping the delay of non-cached tasks below a pre-defined threshold. Hence, the constraint can be written as:

[TABLE]

substituting the queuing time as $W_{ea}^{\textrm{f}}(t)=\sum_{a_{i}\in Q_{e}}\frac{L_{a_{i}}^{\prime}(t)}{r_{ie}(t)}$:

[TABLE]

where $L_{a_{i}}^{\prime}(t)$ is the remaining task data of task $a_{i}$ in the queue $Q_{e}$ of cloudlet $e$ at time instant $t$. Finally, the constraint can be expressed as:

[TABLE]

The above constraint implies that to reach the desired reliability, a maximum value of $\frac{L_{a}}{\bar{r}_{ue}(t)}$ is allowed for the newly admitted requests to the queue of cloudlet $e$. The average service rate $\bar{r}_{ue}(t)$ is estimated at each cloudlet $e$ for each UN $u$ within its coverage using a time-average rate estimation method, as follows:

[TABLE]

Next, we propose a joint matching [14] and caching scheme to solve the optimization problem in (4).

III Joint Task Matching and Caching

To simplify the computational complexity of the optimization problem in (4), we decouple the problem into two separate subproblems: distributing UN tasks to cloudlets and caching popular cacheable task results. Due to the large size of IoT networks, it is not practical to perform task matching over the whole network set of cloudlets and UNs. Therefore, a clustering scheme is introduced to group UNs into disjoint sets based on spatial proximity and mutual interest in popular tasks, followed by the calculation of a task popularity matrix. Subsequently, a joint task distribution and caching scheme is proposed. UN clustering and task popularity matrix calculations are assumed to be performed during a network training period during which information about UNs’ requests and their serving cloudlets are reported to a higher level controller, e.g. a cloud data center. While a central controller is involved in the training period calculations, we emphasize that this process does not need to be updated as frequently as the task distribution and caching processes, since a given user’s interests are likely to remain unchanged for a number of time instants $N_{t}$ ($\gg 1$).

III-A Network Clustering and Task Popularity Matrix

We start by grouping UNs into $k$ disjoint clusters $\mathcal{C}_{1},\ldots,\mathcal{C}_{k}$ based on their mutual-coupling in distance and task popularity such that a task popularity matrix, defined as $\boldsymbol{\Xi}=[\boldsymbol{\xi}_{1},\ldots,\boldsymbol{\xi}_{k}]$ is calculated, where $\boldsymbol{\xi}_{i}$ is a vector of the popularity order of tasks in cluster $\mathcal{\mathcal{C}}_{i}$. Essentially, identifying the similarities between neighboring UNs and their mutual interests is the first step in bringing computing resources closer to them. To that end, we exploit the similarity of different UNs in terms of their similar task popularity patterns to allow cloudlets in their proximity to store the computing results of their tasks.

III-A1 Distance-based Gaussian similarity

The Gaussian similarity metric is used to quantify the similarity between UNs based on their inter-distance. A distance Gaussian similarity matrix is defined as $\boldsymbol{S}_{d}=[d_{ij}]$, with $d_{ij}$ being:

[TABLE]

where $\boldsymbol{v}_{i}$ is a vector of the geographical coordinates of UN $i$, and $\sigma_{d}$ is a similarity parameter to control the neighborhood size.

III-A2 Task popularity-based similarity

To discover the task popularity patterns of different UNs, the task request occurrence is recorded for each UN during a training period set. Subsequently, a task occurrence vector $\boldsymbol{n}_{u}=[n_{u,1},\ldots,n_{u,\mid\mathcal{A}_{c}\mid}]$ is calculated for each UN. This vector captures the UN’s task arrival rate and helps to build similarity between UNs. A cosine similarity metric is considered to measure the similarity between UNs. The task popularity similarity matrix is $\boldsymbol{S}_{p}=[p_{ij}]$, where $p_{ij}$ is expressed as:

[TABLE]

III-A3 UN clustering and popularity matrix calculation

Since we are interested in groups of UNs that are close to each other and having similar task popularity patterns, we consider a similarity matrix that blends the distance and task popularity matrices together. The similarity matrix $S$ is calculated as:

[TABLE]

where $\theta$ is a parameter that adjusts the impact of distance and task popularity. Subsequently, we use spectral clustering [15] to group UNs into $k$ disjoint clusters, $\mathcal{C}_{1},\ldots,\mathcal{C}_{k}$.

To bring the popular tasks closer to the network edge, the task popularity matrix of UN clusters is reported to cloudlets so that they cache the computing result of the most popular tasks. Accordingly, the most preferred cluster by a cloudlet is obtained by calculating how frequently the members of each cluster were assigned to this specific cloudlet during the training period. The vector $\boldsymbol{\xi}_{i}$ of tasks that are most popular for a cluster $i$ is reported to the cloudlets that have cluster $\mathcal{C}_{i}$ as their most preferred cluster. The proposed UN clustering and task popularity matrix calculation is described in Algorithm 1.

III-B *Computing Caching Scheme *

During network operation, cloudlets seek to minimize the service delay of their UNs’ requests by proactively caching the computing results of the popular tasks they receive. The caches of each cloudlet are assumed to be empty at the beginning of the network operation. As UNs start to offload computing tasks, cloudlets will cache as many computing results as their storage capacity allows. Once a cloudlet’s storage is full, a new arriving request that is more popular than the least popular task currently in the cache will replace it. The algorithm implementation per cloudlet is described in Algorithm 2.

Next, if the cloudlet receives a computation request of a task that is cached in its storage, there is no need to offload the task data or recompute the task, and only processing delay is incurred. Each cloudlet aims to find the optimal caching policy that minimizes the total latency.

III-C UN Task Distribution

Our next step is to propose a task distribution scheme that solves the constrained minimization problem in (4). The task distribution problem is formulated as a matching game between UNs and cloudlets where, at each time instant, UNs requesting new tasks are matched to a serving cloudlet aiming to minimize their service delay. Matching theory [14] is a framework that solves combinatorial problems in which members of two sets of players are interested in forming matching pairs with a player from the opposite set. Preferences of both the cloudlets and UNs, denoted $\succ_{e}$ and $\succ_{u}$, represent how each player ranks the players of the opposite set.

Definition 1**.**

Given the two disjoint sets of cloudlets and UNs $(\mathcal{E},\mathcal{U}$), a matching is defined as a one-to-one mapping $\Upsilon$ from the set $\mathcal{E}\cup\mathcal{U}$ into the set of all subsets of $\mathcal{E}\cup\mathcal{U}$, such that for each $e\in\mathcal{E}$ and $u\in\mathcal{U}$:

For each u\in\mathcal{U},$$\Upsilon(u)\in\mathcal{E}\cup u, where $\Upsilon(u)=u$ means that a UN is not matched to a cloudlet, but will perform local computing instead. 2. 2.

For each e\in\mathcal{E},$$\Upsilon(e)\in\mathcal{U}\cup\{e\}, where $\Upsilon(e)=e$ means that no UN is assigned to the cloudlet $e.$ 3. 3.

$\mid\Upsilon(u)\mid=1,\mid\Upsilon(e)\mid=1$;  4)$\Upsilon(u)=e\Leftrightarrow\Upsilon(e)=u$.

By inspecting the problem in (4), we can see that the constraints (4c)-(4d) are satisfied by the one-to-one mapping of the matching game. Moreover, matching allows defining preference profiles that capture the cost function of the players. To this end, the preference profiles of UNs are defined so as to minimize their task service delay as follows:

[TABLE]

[TABLE]

Note that since a UN has no information about the queue length at each cloudlet, it considers the transmission, computing and processing delay of its own task data in calculating its preference profile.

The utility of cloudlets will essentially reflect the latency and reliability constraint in (7), taking into account the waiting time in the queue. Therefore, we define the utility when UN $u$ is assigned to cloudlet $e$ as:

[TABLE]

The preference of each cloudlet can be expressed as follows:

[TABLE]

[TABLE]

where (16) states that a cloudlet is not interested in being matched to a UN that will violate its reliability constraint. In other words, the utility of each cloudlet is to seek a matching that maximizes the difference between the right hand side and the left hand side of the inequality in (7), such that the constraint is met as a stable matching is reached.

The above problem is a one-to-one matching game. Next, we define matching stability and provide an efficient algorithm based on deferred acceptance (DA) [14] to solve this game.

Definition 2**.**

Given a matching $\Upsilon$ with $\Upsilon(e)=u$ and $\Upsilon(u)=e$, and a pair $(u^{\prime},e^{\prime})$ with $\Upsilon(e)\neq u^{\prime}$ and $\Upsilon(u)\neq e^{\prime}$, $(u^{\prime},e^{\prime})$ is said to be blocking the matching $\Upsilon$ and form a blocking pair if: 1) $u^{\prime}\succ_{e}u$, 2) $e^{\prime}\succ_{u}e$. A matching $\Upsilon*$ is stable if there is no blocking pair.

Remark** 1**. DA algorithm described in Algorithm 3, converges to a two-sided stable matching of UNs to cloudlets [14].

IV Simulation Results

In this section, we present and illustrate insights from simulation results of the proposed scheme. We also compare the proposed proactive computing scheme against the following two baseline schemes:

Baseline 1, which is a reactive version of the proposed scheme, in which the latency and reliability constrained task distribution scheme is considered, but with no caching capabilities in the cloudlets. 2. 2.

Baseline 2, in which latency and reliability constraints are not considered. Instead, UNs and cloudlets rank each other based on the wireless access link quality, without taking delay queues or proactiveness into account.

We use a set of default parameters333$E=30$ cloudlets, $U=3\times 30$ UNs, $\mid A\mid=90$ tasks, $z=0.6$, $D_{\textrm{th}}=1\textrm{s}$, $\epsilon=0.01$, UN power = $20$ dBm, $\theta=0.5$, $\sigma_{d}^{2}=500$, $\nu(t)=1/t^{0.55}$, $\kappa/c_{\textrm{local}}=10^{-7},\kappa/c_{e}=10^{-8}$, $s_{e}=10$ tasks, \text{\tau}_{\textrm{LP}}=\textrm{Unif}(0,\tfrac{1}{8})\textrm{\,ms}, \text{\tau}_{\textrm{EP}}=\textrm{Unif}(\tfrac{1}{8},\tfrac{1}{4})\textrm{\,ms}. unless stated otherwise. Three different sets of task popularity distributions are assigned randomly to UNs, where popularity varies among tasks following the Zipf popularity model with parameter $z$ [10]. Accordingly, the request rate for the $i^{\textrm{th}}$ most popular task is proportional to $1/i^{z}$. Furthermore, one third of the tasks, uniformly selected, are assumed to be cacheable.

IV-A Proactiveness and Computation Delay

In Fig. 2, we show the tail distribution of the instantaneous total computing delay, i.e., the complementary cumulative distribution function (CCDF) $\bar{F_{D}}(d)=\Pr(D>d)$, for different schemes. The proposed scheme is simulated for different proactiveness levels of $1/3$ and $1/6$. In other words, the cloudlet storage can store up to $1/3$ and $1/6$ of the computing results of the cacheable tasks. From Fig. 2, we can see that the proposed scheme maintains a $99\%$ reliability constraint ($\epsilon=0.01$) for both the proactive and the reactive cases. Moreover, the probability of having higher delay values significantly decreases as the proactiveness level increases since storing more computing results closer to UNs will further reduce the computing delay.

The average total delay performance is presented in Fig. 5 under different proactiveness levels. Comparing Baseline 1 and Baseline 2 schemes, about $72\%$ decrease in the average computing delay can be seen. In Baseline 2 scheme, requests that will violate the latency constraints are not admitted, and are computed locally instead. Furthermore, the proactive scheme significantly decreases the computing delay as the proactiveness level increases. By storing more computing results close to UNs, up to $91\%$ decrease in delay is observed.

The impact of proactiveness on the delay and cache hit rate is investigated in Fig. 5 for different discrepancy levels of the task popularity distributions, represented by the Zipf parameter $z$. As $z$ increases, the popularity gap between the most and least popular tasks increases. At high values of $z$, most of the computing requests are for the most popular tasks. Accordingly, it is possible to serve more requests from the cache, resulting in low computing delay and high cache hit rate, even at low proactiveness levels. On the other hand, at low values of $z$, high proactiveness levels are needed to store the most popular task results. Therefore, a steep decrease in computing delay and an increase in the cache hit rate are observed as proactiveness level increases.

IV-B Impact of Traffic Intensity

Next, we study how the performance changes with the traffic intensity. Intuitively, at low traffic intensity conditions, cloudlets can cope with the computing requests with minimal latency, and there is no need to assign requests to local computing. However, at high traffic conditions, offloading all requests causes the cloudlet queues to grow rapidly, unless stringent latency requirements are imposed. From Fig. 5, we can see that as the traffic intensity increases, there exists a threshold point in which higher traffic intensity will cause severe delay for the baseline scheme with unbounded latency. Below this point, Baseline 1 scheme achieves similar or lower delay values than Baseline 2 as there is no compelling need to maintain latency bounds by assigning requests to local computing. Moreover, both the reactive and proactive schemes achieve low delay performance, with proactiveness gains of up to $65\%$ at high traffic intensity.

V Conclusions

In this paper, we have proposed a task distribution and proactive computing scheme for cache-enabled fog computing networks under ultra-reliability and low-latency constraints. In the proposed scheme, clusters of cloudlets and edge user nodes are formed based on spatial proximity and similar interests in computing results. To ensure minimal computing delays, each cluster proactively caches computing results in the storage of its cloudlets. Moreover, we have proposed a matching algorithm to distribute the computing tasks to cloudlets such that computing delay is minimized and latency constraints are met. Simulation results have shown that the proposed scheme significantly minimizes the computing delay under different proactiveness and traffic intensity levels, and is able to guarantee minimal latency bounds with high levels of certainty.