 Joint Communication, Computation, Caching, and Control in Big Data Multi-access Edge Computing

The concept of multi-access edge computing (MEC) has been recently introduced to supplement cloud computing by deploying MEC servers to the network edge so as to reduce the network delay and alleviate the load on cloud data centers. However, compared to a resourceful cloud, an MEC server has limited resources. When each MEC server operates independently, it cannot handle all of the computational and big data demands stemming from the users' devices. Consequently, the MEC server cannot provide significant gains in overhead reduction due to data exchange between users' devices and remote cloud. Therefore, joint computing, caching, communication, and control (4C) at the edge with MEC server collaboration is strongly needed for big data applications. In order to address these challenges, in this paper, the problem of joint 4C in big data MEC is formulated as an optimization problem whose goal is to maximize the bandwidth saving while minimizing delay, subject to the local computation capability of user devices, computation deadline, and MEC resource constraints. However, the formulated problem is shown to be non-convex. To make this problem convex, a proximal upper bound problem of the original formulated problem that guarantees descent to the original problem is proposed. To solve the proximal upper bound problem, a block successive upper bound minimization (BSUM) method is applied. Simulation results show that the proposed approach increases bandwidth-saving and minimizes delay while satisfying the computation deadlines.

Communication, Computation, Caching, Distributed control, Multi-access edge computing, 5G network

Introduction {#sec:introduction}
============

Background and Motivations
--------------------------

In recent years, wireless users have become producers and consumers of contents as their devices are now embedded with various sensors @jin2015quality, which help in creating and collecting various types of data from different domains such as energy, agriculture, healthcare, transport, security, and smart homes, among others. Indeed, by the year $2020$, it is anticipated that $50$ billion things will be connected to the Internet, which is equivalent to $6$ devices per person on the planet @Cisco. Therefore, the devices of wireless users will be anywhere, anytime, and connected to anything @zeydan2016big. This large-scale interconnection of people and things, there will be a tremendous growth of data traffic (from user devices) with different characteristics (unstructured, quasi-structured, and semi-structured) whose scale, distribution, diversity, and velocity fall into a big data framework that requires big data infrastructure and analytics. Since the resources (e.g., battery power, CPU cycles, memory, and I/O data rate) of edge user devices are limited, edge user devices must offload computational tasks and big data to the cloud. However, for effective big data analytics of delay sensitive and context-aware applications, there is a strong need for low-latency and reliable computation. As such, reliance on a cloud can hinder the performance of big data analytics, due to the associated overhead and end-to-end delays @zeydan2016big [@ferdowsi2017deep].

To reduce end-to-end delay and the need for extensive user-cloud communication, *multi-access edge computing (MEC)* has been introduced by the European Telecommunications Standards Institute (ETSI) as a supplement to cloud computing and mobile edge computing @hu2015mobile. MEC extends cloud computing capabilities by providing IT-based services and cloud computing capabilities at the networks edges. In other words, MEC pushes computation, caching, communication, and control (4C) to the edge of the network @patel2014mobile. Typically, MEC servers are deployed at the base stations (BSs) of a wireless network (e.g., a cellular network) for executing delay sensitive and context-aware applications in close proximity to the users @semiari2015context [@tran2017collaborative; @ndikumana2017collaborative]. Therefore, data and computational task offloading to a nearby MEC server can significantly reduce the end-to-end delay, data exchange between users and the remote cloud, and solve the problem of moving data to the remote cloud and returning computation outputs to the users. In other words, data will be offloaded, processed, analyzed, and cached at the edge of the network , e.g., MEC servers, near where data is created.

Since offloading requires communication resources, joint optimization of 4C is needed for having an appropriate model that reduces communication and computational delay, while saving backhaul bandwidth. As an example, CCTV security systems use many cameras covering an area for locating people and objects, such as criminals, intruders, missing children, stolen cars, and accidents, where the CCTVs can capture real-time useful videos. Sending real-time streaming videos to a remote cloud for processing and returning the results can strain the network and increase backhaul bandwidth expenses. However, sending real-time streaming videos to nearby MEC servers that can process the videos (e.g., perform object recognition or parsing functions) and return the results can potentially reduce resource usage (e.g., bandwidth) and minimize delay. In addition, the MEC server can cache the videos in its local storage for later use. Therefore, in order to satisfy users' demands, MEC servers located in the same area can *collaborate* through sharing resources.

MEC Challenges for Dealing with Big Data
----------------------------------------

The most important challenges that MEC is still facing when dealing with big data and edge analytics are:

-   Users offload tasks and corresponding data with varying rates. In other words, data from multiple users may reach MEC servers too rapidly with finite or infinite flow (e.g., streaming data), and this data needs to be processed immediately (e.g., live stream computation and caching, real-time analytics) @dutta2015big. A MEC server will find it challenging to deal with such data due to its scale, diversity, and timeliness. Therefore, for fast, parallel, and distributed processing, MEC servers must support big data platform and analytics applications for splitting data volume, distributing computations to multiple computing nodes, replicating data partitions, and recovering data when needed.

-   MEC server resources are limited compared to a remote cloud @ahmed2017mobile. Therefore, the MEC server cannot significantly relieve the data exchange between users' devices and a remote cloud and handle big data MEC efficiently when each MEC server operates independently. Therefore, to reduce the delay, cooperation among MEC servers for resource sharing and optimization of the resource utilization are needed.

-   The integration of MEC with a mobile network environments raise a number of challenges related to the coordination and control of joint communication, computation and caching, and thus, computation and caching depend on the available communication resources. Therefore, joint 4C for big data MEC is needed.

Contributions
-------------

In this work, we address these challenges of joint 4C for big data processing in MEC. The main contributions of this paper are summarized as follows:

-   We propose a framework for joint 4C for big data MEC, where big data computation and caching functions are performed at an MEC server instead of being sent to a remote cloud. This allows the reduction of the end-to-end delay and data exchange between users and a remote cloud.

-   For satisfying user demands and efficiently executing computational tasks and data caching in big data MEC, we introduce a MEC-based collaboration space or cluster, where MEC servers located in the same cluster collaborate with each other. The aim of the collaboration in MEC is to reduce the backhaul network traffic, minimize delay in coupled 4C, and maximize resource utilization.

-   In order to minimize the communication delay among MEC servers and to allow collaboration, inspired by the unsupervised machine learning algorithm called the overlapping k-mean method (OKM) @cleuziou2008extended, we propose OKM for collaboration space (OKM-CS). OKM-CS allows each MEC server to participate in more than one collaboration space. A collaboration space enables collaboration among MEC servers, which is not only based on distance measurements, but also based on available resources.

-   Within each collaboration space, we formulate a collaborative optimization problem that maximizes bandwidth savings while minimizing delay, subject to the local computation capabilities of users, computation deadlines, and MEC resources constraints. The formulated problem is shown to be non-convex, and hence, in order to solve it, we propose a proximal upper-bound problem of the original problem and apply the block successive upper bound minimization (BSUM) method, where BSUM is considered as a new and powerful framework for big-data optimization @han2017signal.

-   Simulation results show that the proposed approach increases bandwidth-saving and minimizes both computation and offloading delay while satisfying user computation deadlines.

The rest of the paper is organized as follows. In Section \[sec:RW\], we discuss some related works, while Section \[sec:SystemModel\] presents the system model. Section \[sec:CollaborativeCacheComputation\] discusses in detail our joint 4C for big data MEC, while Section \[sec:PE\] provides a performance evaluation. We conclude the paper in Section \[sec:Conclusion\].

Literature Review {#sec:RW}
=================

The existing, related works can be grouped into four categories: (i) big data and caching, (ii) joint caching and computation, (iii) joint caching and communication, and (iv) joint caching, computation, and communication.

*Big data and caching:* In @bacstuug2015big, the authors proposed a big data framework for mobile network optimization using data from both network features and user features. On the other hand, implementing the big data framework at the network edge can be challenging due to the fact that caching spaces at edge nodes are usually small, which can potentially result in a low hit ratio. To overcome this challenge, in @tran2017collaborative, the authors highlighted the need of having cooperative caching that allows low latency content delivery. In addition to caching, in @zeydan2016big, the authors tried to establish connections between big data and caching in 5G wireless networks, where statistical machine learning is applied for estimating content popularity. Other machine learning approaches are surveyed in @chen2017machine.

*Joint caching and computation (2C):* In @fan2016terminalbooster, the authors combined caching and computation at BSs for decreasing delays occurring during communication between applications running on user devices and a remote cloud. They developed a resource management algorithm that guides the BS to jointly schedule computation offloading and data caching allocation. In @lee2017online, the idea of low-latency computations is explored using the online secretary framework, where the computational tasks are distributed between the edge networks and cloud. Furthermore, for efficient resource usage at the BS level, in @tran2016collaborative, the authors proposed a collaborative video caching and processing scheme in which MEC servers can assist each other. They formulated the collaborative joint caching and processing problem as an optimization problem that aims to minimize the backhaul network cost, subject to cache capacity and processing capacity constraints. In @chen2016mobility, the authors proposed a joint mobility aware caching and small cell base station placement framework. Also, the authors discussed the differences and relationships between caching and computation offloading.

*Joint caching and communication (2C):* In @jiang2017optimal, in order to significantly reduce redundant data transmissions and improve content delivery, the authors highlighted the need of having efficient content caching and distribution techniques. They proposed an optimal cooperative content caching and delivery policy in which both femtocell BSs and user equipment participate in content caching. In @hsu2016resource, the authors studied the problem of resource allocation along with data caching in radio access networks (RANs). They proposed a collaborative framework that leverages device-to-device (D2D) communication for implementing content caching. In @tan2017joint, a communication framework related to cache-enabled heterogeneous cellular networks with D2D communication was studied. In order to satisfy quality-of-service (QoS) requirements for the users, the authors formulated a joint optimization problem that aims at maximizing the system capacity in which bandwidth resource allocation was considered. The problem of joint caching and communication for drone-enabled systems is also studied in @chen2017caching.

*Joint caching, computation, and communication (3C):* In @zhou2017resource, the authors combined 3C for designing a novel information centric heterogeneous network framework that enables content caching and computing in MEC. They considered visualized resources, where communication, computing and caching resources can be shared among all users associated with different virtual service providers. Since MEC can enhance the computational capabilities of edge nodes, in @wang2017computation, the authors formulated a computation offloading decision, resource allocation and data caching framework as an optimization problem in which the total revenue of the network is considered. Furthermore, in @huo2016software, the authors proposed an energy-efficient framework that considers joint networking, caching, and computing whose goal is to meet the requirements of the next generation of green wireless networks. Moreover, for MEC applications, in @chakareski2017vr, the authors explored the fundamental tradeoffs between caching, computing, and communication for VR/AR applications. Finally, the work in @cui2017energy proposed a joint caching and offloading mechanism that considers task uploading and executing, computation output downloading, multi-user diversity, and multi-casting.

In @bacstuug2015big [@zeydan2016big; @fan2016terminalbooster; @zhou2017resource; @wang2017computation; @huo2016software], and @cui2017energy, the authors consider edge caching. However, edge nodes are resources limited as compared to the cloud. Therefore, without cooperation among edge nodes, edge caching can result in a low cache hit ratio. In order to overcome this issue, in @tran2017collaborative and @tran2016collaborative, the authors proposed the idea of a collaboration space for edge nodes. However, the works in @tran2017collaborative and @tran2016collaborative do not provide any rigorous framework for analyzing the formation of collaboration spaces. Furthermore, a user may request a content format (e.g., avi), which is not available in the cache storage. Instead, the cache storage may have other content formats (e.g., mpeg) of the same content which can be converted to the desired format, by using certain computations, and then transmitted to the requesting user. This process of serving cached content after computation was not considered in @chen2016mobility [@jiang2017optimal; @hsu2016resource; @tan2017joint; @chen2017caching]. Finally, the works in @fan2016terminalbooster [@zhou2017resource; @wang2017computation; @huo2016software] do not take into account any user deadlines for performing computations, which can be impractical.

To this end, our proposed approach will have several key differences from these prior approaches including: *(i)* while many related works (e.g.,@zhou2017resource [@wang2017computation; @huo2016software; @chakareski2017vr; @cui2017energy]) focus on 2C and 3C, in our proposed approach, we combine 4C in big data MEC in which the computation capabilities of the user devices, computation deadline, size of input data, and MEC resource constraints are considered, *(ii)* The proposed collaboration between MEC servers, where MEC servers are grouped in collaboration spaces via the OKM-CS algorithm, is new in MEC, and thus is not only based on distance measurements, but also based on the availability of resources, *(iii)* Within each collaboration space, for solving the formulated collaborative optimization problem, we apply the BSUM method, which is not yet utilized in existing MEC solutions. The BSUM method is a novel and powerful framework for big-data optimization @han2017signal. The BSUM method allows the decomposition of the formulated optimization problem into small subproblems which can be addressed separately and computed in a parallel.

![Illustration of our system model.<span data-label="fig:SystemModel"></span>](system_model.eps){width="0.90\columnwidth"}

  Notation                                                         Definition
  ---------------------------------------------------------------- ------------------------------------------------------------------------------------
  $\mathcal{M}$                                                    Set of MEC servers, $|\mathcal{M}|= M$
  $\mathcal{K}$                                                    Set of users, $|\mathcal{K}|= K$
  $C_m$                                                            Total cache capacity at MEC server $m \in \mathcal{M}$
  $P_m$                                                            Total computation capacity at MEC server $m \in \mathcal{M}$
  $s(d_k)$                                                         Size of data $d_k$, $\forall k \in \mathcal{K}$
  $\tilde{\tau}_{k}$                                               Computation deadline, for $k \in \mathcal{K}$
  $\tilde{z}_{k}$                                                  Computation workload, $\forall k \in \mathcal{K}$
  $\lambda^{d_k}_m$                                                Request arrival rate for data $d_k$
                                                                   at MEC $m \in \mathcal{M}$
  $l_k$                                                            Execution latency, $\forall k \in \mathcal{K}$
  $E_{k}$                                                          Computation energy, $\forall  k \in \mathcal{K}$
  $\tilde{E_{k}}$                                                  Available energy in user device $k\in \mathcal{K}$
  $ x_k^m$                                                         Computation offloading decision variable,
                                                                   for $k \in \mathcal{K}$, and $m \in \mathcal{M}$
  $y^{m\rightarrow n}_k  $                                         Computation offloading decision variable,
                                                                   for $m,n \in \mathcal{M}$
  $w_m^k$                                                          Data caching decision variable, $\forall k \in \mathcal{K}_m, \;m \in \mathcal{M}$
  $\gamma^m_k$                                                     Spectrum efficiency, $\forall k \in \mathcal{K}_m$, and $m \in \mathcal{M}$
  $R^m_k$                                                          Instantaneous data rate, $\forall k \in \mathcal{K}_m$, and $m \in \mathcal{M}$
  $\tau_k^{k\rightarrow  m}$                                       Offloading delay, $\forall k \in \mathcal{K}_m$, and $m \in \mathcal{M}$
  $T_{k}$                                                          Task from user $k \in \mathcal{K}$
  $\tau^e_{km}$                                                    Total executing time of offloaded task,
                                                                   $\forall k \in \mathcal{K}_m$, $m \in \mathcal{M}$
  $\Theta({\boldsymbol{x}},{\boldsymbol{y}})$                      Total delay
  $ \Psi({{\boldsymbol{x}},{\boldsymbol{y}}, {\boldsymbol{w}}})$   Alleviated backhaul bandwidth

  : Summary of notations.<span data-label="tab:table1"></span>

System Model {#sec:SystemModel}
============

As shown in Fig. \[fig:SystemModel\], we consider an MEC network composed of a set $\mathcal{M}$ of MEC servers, each of which is attached to one BS. Unless stated otherwise, we use the terms "MEC server" and "BS" interchangeably.

Each MEC server collaborates with other MEC servers by sharing resources. Therefore, we group the BSs into *collaboration spaces (i.e., clusters)*. Unless stated otherwise, we use the terms "collaboration space" and "cluster" interchangeably. In order to minimize the communication delay among MEC servers, our clustering process for BSs is based on proximity (distance) measurements, where BSs that are close enough will be grouped in the same cluster. Moreover, in our collaboration space, we focus on geographic space coverage rather than geographical space partitioning. As an example, some MEC servers in the hotspot area may want to collaborate with MEC servers not in the hotspot. To achieve this objective, we consider an overlapping clustering method that allows one BS to belong to more than one cluster and to share resources not only based on distance measurements, but also based on resource availability and utilization.

For creating collaboration spaces, we propose OKM for collaboration space (OKM-CS), which is a modified version of the standard OKM algorithm @cleuziou2008extended. The merit of the OKM algorithm lies in its elegant simplicity of implementation over other overlapping methods such as weighted OKM (WOKM), overlapping partitioning cluster (OPC), and multi-cluster overlapping k-means extension (MCOKE) @baadel2016overlapping. OKM-CS is described in Section \[sec:CollaborativeCacheComputation\], Algorithm \[algo:OKM\].

In a collaboration space, each MEC server $m$ has both caching and computational resources that are divisible. We let $C_m$ and $P_m$ be, respectively, the cache capacity and computational capacity of MEC server $m$. In any given collaboration space, MEC servers can exchange data and tasks based on their available resources. Moreover, we assume that the MEC servers within a collaboration space belong to the same mobile network operator (MNO), and this MNO has a total storage capacity $C$, and a total computation capacity $P$. The total cache storage pool for the MNO in a collaboration space is given by: $$\begin{aligned}
C= \sum_{m \in \mathcal{M}} C_m,
\end{aligned}
\label{eq:totalcache}$$ while the computation pool of the MNO is given by: $$\begin{aligned}
P= \sum_{m \in \mathcal{M}} P_m.
\end{aligned}
\label{eq:computation}$$

We assume that each MEC server $m $ uses a resource allocation table (RAT) for keeping track of the available resources in the collaboration space, including CPU utilization, RAM, and storage capacity. In order to facilitate joint 4C in big data MEC, in collaboration space, MEC servers exchange RAT updates. However, for the resources that are not available in a collaboration space, MEC server $m$ forwards the associated requests to the remote data center (DC). Therefore, for effective resource utilization, resources are sliced for being allocated to multiple users.

We consider a set $\mathcal{K}$ of users, where each user $k \in \mathcal{K}$ is connected to its nearest BS, referred to as its home BS. The set of users connected to the same BS $m\in M$ is denoted by a subset $\mathcal{K}_m \subset \mathcal{K}$. We assume that the user devices have limited resources for both computation and caching. Therefore, instead of sending resource demands to the DC, based on user demands, MEC servers can provide computation and storage resources to the users. As an example, drones in professional sports activities can cover the event scenes and send live stream videos to their nearest MEC server $m$ for live stream caching, processing, and distribution. Based on the network conditions, user demands, and device capabilities, the cached data can be served as is or after computation (e.g., video transcoding).

In our model, each user device $k \in \mathcal{K}$ has an application that needs to use computation and caching resources, such as augmented reality, online gaming, crowdsensing, image processing, or CCTV video processing.

We consider a binary task offloading model in which a task is a single entity that is either computed locally at a user device or offloaded to the MEC server. For each user $k$, we define a task $T_{k} = (s(d_k),\tilde{\tau}_{k}, \tilde{z}_{k}),\ \forall k \in \mathcal{K}$, where $s(d_k)$ is the size of data $d_k$ from user $k$ in terms of the bits that are needed as an input of computation, $\tilde{\tau}_{k}$ is the task computation deadline, and $\tilde{z}_{k}$ is the computation workload or intensity in terms of CPU cycles per bit. Furthermore, we assume that the resource demands of different users are independent.

![Illustration of big data MEC.<span data-label="fig:big-data"></span>](big-data.eps){width="0.7\columnwidth"}

In order to satisfy user demands, as depicted in Fig \[fig:big-data\], we consider each MEC server to be a small big data infrastructure that supports the big data cloud requirements defined in @kune2016anatomy, including ($i$) Easy setup of virtual machines, mounting file systems, and deployment of big data platform and analytics software such as Hadoop, Spark, Storm, and Splunk; ($ii$) Dynamic management of computation, storage, and network resources, either on physical or virtual environments; ($iii$) Elasticity and scalability in computation, storage and network resources allocation; ($iv$) Development, deployment and utilization of big data analytics with fast access to data and computing resources; and ($v$) Support for multi-dimension data handling, where data may reach the MEC server in different forms and characteristics.

Proposed Joint Communication, Computation, Caching, and Control {#sec:CollaborativeCacheComputation}
===============================================================

In this section, we describe, in detail, our proposed approach for joint communication, computation, caching, and distributed control in big data MEC, where MEC server resources are virtualized and shared by multiple users. Resource demands that are not satisfied at one MEC server can be satisfied by any other MEC server in the same collaboration space.

Collaboration Space {#subsec: collaboration-space}
-------------------

For forming collaboration spaces, we propose OKM-CS. OKM-CS seeks to cluster the BSs into $r$ clusters such that the below objective function is minimized: $$\begin{aligned}
\mathcal{I}(\{\mathcal{M}_i\}_{i=1}^r)=\sum_{i=1}^r   \sum_{m \in \mathcal{M}_i}\lVert m-\Phi(m)\rVert^2,
\end{aligned}
\label{eq:OKM_objective}$$ where $\mathcal{M}_i\subset \mathcal{M}$ represents the $i^{th}$ cluster.

The original OKM algorithm randomly chooses $r$ clusters. However, in OKM-CS for 4C, the number of clusters is chosen based on the network topology, which is known a priori by the MNO. OKM-CS is presented in Algorithm \[algo:OKM\].

Algorithm \[algo:OKM\] starts with an initial set of $r$ clusters and centroid $\{m_{c_i}^{(0)}\}_{i=1}^r$, and derives new coverage $\{\mathcal{M}_i^{(0)}\}_{i=1}^r$. Then, it iterates by computing new assignments and new centroids $\{m_{c_i}^{(t+1)}\}_{i=1}^r$ leading to the new coverage $\{\mathcal{M}_i^{(t+1)}\}_{i=1}^r$. The iterative process continues until the convergence criterion on $\mathcal{I}(\{\mathcal{M}^{(t)}_i\}_{i=1}^r)-\mathcal{I}(\{\mathcal{M}^{(t+1)}_i\}_{i=1}^r)<\epsilon$) is satisfied, where $\epsilon$ is a small positive number. Furthermore, since our focus is on the collaboration among the MEC servers in the same collaboration space, for brevity, hereinafter, we omit the subscript on $\mathcal{M}_i$ and analyze 4C for one collaboration space.

\[t\]

\[1\] centroid;

In a collaboration space, for the MEC resources, each user $k$ must submit a task demand $T_{k}$ to its MEC server $m$. Then, the MNO maps the demands into the resource allocation that each user $k$ requires. Therefore, to help the users prepare their demands, the MNO advertises the resources available to them as well as the sum of the demands placed in the collaboration space. However, the MNO does not reveal the demands of the users to each other.

We use $v_{km}(c_{dk},p_{km}, R^m_k)$ to represent the resource allocation function for each user $k$ at MEC server $m$, where $c_{dk}$ is used to denote the caching resource allocation for user data of size $s(d_k)$ (i.e., $c_{dk}=s(d_k)$), $ p_{km}$ is used to denote the computational resource allocation, and $R^m_k$ is used to denote the communication resource allocation.

The MNO allocates resources based on weighted proportional allocation @nguyen2011weighted, which is practical in systems such as 4G and 5G cellular networks @mosleh2016proportional [@lei2015joint]. Each user $k$ receives a fraction of the resources at the MEC server $m$ based on its demand. Furthermore, when $\tilde{\tau}_{k}=0$ and $\tilde{z}_{k}=0$, we consider that the user needs only communication resources for offloading data $d_k$ and caching resources for caching its data. Therefore, an MEC server caches data $d_k$, and waits for the data to be requested later, where $d_k$ can be served as is or after computation. However, when $s(d_k) \neq 0$, $\tilde{\tau}_{k}\neq 0$, and $\tilde{z}_{k} \neq 0$, the MEC server computes, caches the output data of $d_k$, and returns the computation output to user $k$.

Communication Model {#subsec:communication_model}
-------------------

![Collaboration space for MEC with three typical scenarios (a), (b), and (c), which are explained in Section \[subsec:communication\_model\].<span data-label="fig:content_distribution"></span>](system_collaboration.eps){width="1.0\columnwidth"}

To offload a task from a user to the MEC server, the network will incur a communication cost, where the user can offload tasks through use of the communication scenarios, shown in Fig. \[fig:content\_distribution\] and explained next.

*Scenario (a):* For the resources available at BS $m \in \mathcal{M}$, user $k \in \mathcal{K}$ obtains resources from its MEC server over a wireless channel. We define $ x_k^m\in \{0,1\}$ as a computation offloading decision variable, which indicates whether or not user $k$ offloads the task to its home MEC server $m$ via a wireless channel (denoted by W. channel in Fig. \[fig:content\_distribution\]). $$\setlength{\jot}{10pt}
x_k^m=
\begin{cases}
1,\; \text{if $T_k$ is offloaded from user $k$ to BS $m$},\\
0, \;\text{otherwise.}
\end{cases}$$

Therefore, the spectrum efficiency for user device $k$ is expressed as: $$\label{eq:SINR}
\begin{aligned}
\gamma^m_k = \log_2\left(1 + \frac{\rho_k |G^m_k|^2}{\sigma_k^2}\right),  \;\forall k \in \mathcal{K},\; m \in \mathcal{M},
\end{aligned}$$ where $\rho_k$ is the transmission power of user device $k$, $|G^m_k|^2$ is the channel gain between user device $k$ and BS $m$, and $\sigma_k^2$ is the power of the Gaussian noise at user $k$.

The instantaneous data rate for user device $k$ is given by: $$R^m_k= x_k^ma_k^m B_m\gamma^m_k, \forall k \in \mathcal{K},\; m \in \mathcal{M}, 
\label{eq:instantaneous_data}$$ where each user $k$ of BS $m$ is allocated a fraction $a_k^m$ ($ 0\leq a_k^m \leq 1$) of bandwidth $B_m$. We assume that the spectrum of the MNO is orthogonal so that there is no interference among the users. Furthermore, we assume that user demand for offloading will only be accepted if there is enough spectrum resources to satisfy its demand.

Based on the instantaneous data rate, as defined in @mao2017survey, the transmission delay for offloading a task from user $k$ to the MEC server $m$ is expressed as:

$$\tau_k^{k \rightarrow m}=\frac{x_k^m s(d_k)}{R^m_k}, \; \forall k \in \mathcal{K}_m,$$

where $\mathcal{K}_m$ is a set of users served by BS $m$.

*Scenario (b):* When the MEC server $m$ has insufficient resources to satisfy the user demand, after checking its RAT, BS $m$ forwards a request to another BS $n$ via an X2 link @x2, in the collaboration space, which has enough resources. Therefore, users can get the resources from different MEC servers with different delay costs.

We define $y^{m\rightarrow n}_k$ as a decision variable, which indicates whether or not the task of user $k$ is offloaded from BS $m$, as follows: $$\setlength{\jot}{10pt}
y^{m\rightarrow n}_k =
\begin{cases}
1,\; \text{if $T_k$ of user $k$ is offloaded from BS $m$}
\\ \; \; \; \;\text{to a neighbor BS $n$,}\\
0,\;\text{otherwise.}
\end{cases}$$

We denote by $\tau^{m\rightarrow n}_k$ the offloading delay between BS $m$ and BS $n$, which is given as follows: $$\tau^{m\rightarrow n}_k=\frac{\sum_{k \in \mathcal{K}_m}y^{m\rightarrow n}_k s(d_k)}{\Gamma^n_m}, \;\forall m,\;n \in \mathcal{M},$$ where $\Gamma^n_m$ is the X2 link capacity between BS $m$ and BS $n$.

*Scenario (c):* When the resources are not available in the whole collaboration space, BS $m$ forwards the request to the remote cloud through a wired backhaul link.

We define $y^{m\rightarrow DC}_k$ as a decision variable that indicates whether or not the task of user $k$ is offloaded by BS $m$ to the DC, as follows: $$\setlength{\jot}{10pt}
y^{m\rightarrow DC}_k=
\begin{cases}
1,\; \text{if $T_k$ is offloaded from BS $m$ to the DC},\\
0, \;\text{otherwise.}
\end{cases}$$

We define $\tau^{m\rightarrow DC}_k$ as the offloading delay between BS $m$ and DC $l$, where $\tau^{m\rightarrow DC}_k$ is given by: $$\tau^{m\rightarrow DC}_k=\frac{\sum_{k \in \mathcal{K}_m}y^{m\rightarrow DC}_k s(d_k)}{\Omega^{DC}_m}, \;\forall m,\; n \in \mathcal{M},$$ where $\Omega^{DC}_m$ is the link capacity between MEC server $m$ and remote DC.

Computation Model {#subsec: computation_model}
-----------------

###  Local Computation at User Device

In our model, we assume that each user device $k \in \mathcal{K}$ has a task $T_{k}$ that needs to use the local computation resource $P_k$ of device $k$. Therefore, the computation of task $T_{k}$ requires CPU energy $E_{k}$, where the energy consumption of CPU computation at user $k$, as defined in @mao2017survey, is expressed as:

$$E_{k}=  s(d_k)\nu \tilde{z}_{k}P_{k}^2,  \;k \in \mathcal{K},$$

where $\nu$ is a constant parameter that is related to the CPU hardware architecture.

In addition to the CPU energy consumption, the computation of task $T_{k}$ requires execution time $l_k$. Therefore, as defined in @mao2017survey, the execution latency for task $T_{k}$ at user device $k$ is given by:

$$\label{eq:compution_time}
l_k=\frac{s(d_k)\tilde{z}_{k} }{P_{k}}.$$

However, when $l_k> \tilde{\tau}_{k}$, $ \tilde{z}_{k}>P_{k}$, or $ E_{k}>\tilde{E_{k}}$, where $\tilde{E_{k}}$ is the actual available energy at user device $k \in \mathcal{K}$, device $k$ does not have enough energy or computation resources to meet the computation deadline, and thus, user $k$ can keep the computational task until the resources become available for local computation via its device. Therefore, we define $\alpha_{k}\in \{0,1\}$ as a user device status parameter for computing task $T_{k}$, where the value of $\alpha_{k}$ can be set as follows: $$\setlength{\jot}{10pt}
\alpha_{k} =
\begin{cases}
0,\; \text{if $\tilde{z}_{k}>P_{k}$, or $l_k>\tilde{\tau}_{k}$, or $ E_{k}>\tilde{E_{k}}$},\\
1, \;\text{otherwise.}
\end{cases}$$

From the value of $\alpha_{k}$, the total local execution time $\tau^\textrm{loc}_{k}$ of task $T_{k}$ at user device $k$ is given by: $$\setlength{\jot}{10pt}
\tau^\textrm{loc}_{k} =
\begin{cases}
l_k\;, \text{if $\alpha_{k}=1$, and  $x_k^m=0$},\\
l_k+ \varphi_k\;, \text{if $\alpha_{k}=0$, and  $x_k^m=0$},\\
0, \; \text{if $\alpha_{k}=0$, and  $x_k^m=1$},\\
\end{cases}$$ where $\varphi_k$ is the average waiting time of task $T_{k}$ until it is locally executed by device $k$.

Each user $k \in \mathcal{K}$ can compute its task $ T_{k}$ locally on its device, when the device has enough resources, in terms of the CPU cycles, energy, or memory, whenever the user device status parameter is $\alpha_{k}=1$. However, if user $k$ decides not to offload its task to an MEC server, it will experience a computational delay $\tau^\textrm{loc}_{k}$. Therefore, if user $k$ cannot keep a given computational task for the future and $l_k> \tilde{\tau}_{k}$, $ \tilde{z}_{k}>P_{k}$, $E_{k}>\tilde{E_{k}} $ ($\alpha_{k}=0$), then this user $k$ can offload the task to MEC server $m$.

### Computation at MEC Server

We consider $P_m$ as the available computational resources at the MEC server $m \in \mathcal{M}$. Furthermore, we define $y_k^{k\rightarrow m}\in \{0,1\}$ as a decision variable, which indicates whether or not MEC server $m$ has to compute the task $T_k$ offloaded by user $k$, where $y_k^{k\rightarrow m}$ is given by:

$$\setlength{\jot}{10pt}
y_k^{k\rightarrow m} =
\begin{cases}
1,\; \text{if $T_k$ offloaded by user $k$}\\
\; \; \; \;\text{is computed at BS $m$},\\
0, \;\text{otherwise.}
\end{cases}$$

The computation allocation $p_{km}$ at BS $m$ can be calculated as follows:

$$p_{km}=P_m\frac{\tilde{z}_{k}}{\sum_{g\in \mathcal{K}_m}\tilde{z}_{g}},\; \forall k  \in \mathcal{K}_m,\; m \in \mathcal{M}.$$

At each MEC server $m$, the total computation allocations must satisfy:

$$\sum_{k\in \mathcal{K}_m}x_k^mp_{km}y_k^{k\rightarrow m}\leq P_m,\; \forall  m \in \mathcal{M}.$$

The execution latency $l_{km} $ for task $ T_{k}$ at MEC server $m$ is given by: $$\label{eq:compution_time_mec}
l_{km} =\frac{s(d_k) \tilde{z}_{k}}{p_{km}}.$$ Therefore, the total execution time for task $T_k$ that was offloaded by user $k$ at MEC server $m$ is given by: $$\tau^e_{km}= \tau^{k\rightarrow  m}_k + l_{km},\; \forall k \in \mathcal{K}_m,\; m \in \mathcal{M}.$$

However, if $\tilde{z}_{k}>p_{km} $ or $\tau^e_{km} > \tilde{\tau}_{k}$ (i.e., MEC server $m$ does not have enough computational resources to meet the computation deadline), MEC server $m$ checks its RAT and offloads the task to any MEC server $n$ that has enough resources to satisfy the demand. Here, $l_{kn}$ is the execution latency for task $ T_{k}$ at MEC server $n$ and can be calculated based on (\[eq:compution\_time\_mec\]). Therefore, the total execution time for a task offloaded by user $k$ to MEC server $n$ becomes: $$\tau^e_{kmn}=\tau_k^{k \rightarrow m} + \tau^{m\rightarrow n}_k + l_{kn},\; \forall k \in \mathcal{K}_m, \text{ and } m,n \in \mathcal{M}.$$

When there are no available resources in a collaboration space, MEC server $m$ offloads the task to the DC. Therefore, the total execution time for task $T_k$ offloaded by user $k$ at DC becomes: $$\tau^e_{kmDC}=\tau_k^{k \rightarrow m} + \tau^{m\rightarrow DC}_k + l_{kDC},\; \forall k \in \mathcal{K}_m, \text{ and } m \in \mathcal{M},$$ where $l_{kDC}$ can be calculated from (\[eq:compution\_time\_mec\]). Furthermore, we find the total offloading and computation latency $\tau^\textrm{off}_{k}$ for task $T_k$ offloaded by user $k$ as follows: $$\begin{aligned}
\tau^\textrm{off}_{k}=y_k^{k\rightarrow m}\tau^e_{km} + \sum_{n\in \mathcal{M}}y^{m\rightarrow n}_k\tau^e_{kmn}+ y^{m\rightarrow DC}_k\tau^e_{kmDC},\\ \forall k \in \mathcal{K}_m, \text{ and } m \in \mathcal{M}.
\end{aligned}$$

In order to ensure that task $T_k$ is executed at only one location, i.e., computed locally at a user device, at one of the MEC servers, or at the remote cloud, we impose the following constraints, $\forall m \in \mathcal{M}$: $$\begin{aligned}
\setlength{\jot}{10pt}
(1-x^m_k) + x^m_k(y_k^{k\rightarrow m}+\sum_{n\in \mathcal{M}}y^{m\rightarrow n}_k + y^{m\rightarrow DC}_k)= 1,
\label{eq:offloading_constraint}\end{aligned}$$ $$\begin{aligned}
\max \{y_k^{k\rightarrow m}, y^{m\rightarrow n}_k, y^{m\rightarrow DC}_k,\forall n  \}\leq x^m_k, \;\forall k\in \mathcal{K}_m.
\label{eq:green-constraint-59}\end{aligned}$$

Caching Model {#subsec:caching_model}
-------------

For an offloaded task $ T_{k}$, when $\tilde{\tau}_{k}=0$ and $\tilde{z}_{k}=0$, MEC server $m$ caches data $d_k$. Based on user $k$'s demand $\lambda^{d_k}_m$ for data $d_k$ that reaches each MEC server $m$, $d_k$ can be retrieved from the cache storage. Here, using the idea of a cacheable task that was defined in @elbamby2017proactive, we assume that all tasks are cacheable. However, due to the limited cache capacity, the MNO needs to evict from cache the least frequently reused data in order to make room for new incoming data that needs to be cached. During data replacement, the MEC server starts replacing the least frequently reused data based on the number of requests $\lambda^{d_k}_m$ that are satisfied by the MEC severs, i.e., the number of cache hits. Here, the well-known least frequently used (LFU) cache replacement policy @lee2001lrfu @ndikumana2016scalable is applied.

We let $w_m^k\in \{0,1\}$ be the decision variable that indicates whether or not MEC server $m$ has to cache data $d_k$ of user $k$, where $w_m^k$ is given by: $$\setlength{\jot}{10pt}
w_m^k=
\begin{cases}
1,\; \text{if MEC server $m \in \mathcal{M}$ caches the data $d_k$},\\
0, \;\text{otherwise.}
\end{cases}$$

We let $C_m$ be the cache capacity available at any MEC server $m$. Therefore, the total allocation of caching resources at MEC server $m$ must satisfy: $$\begin{aligned}
\label{eq:cache_allocation}
\left(\sum_{k\in \mathcal{K}_m} y_k^{k \rightarrow m} + \sum_{n\neq m\in \mathcal{M}}\sum_{k\in \mathcal{K}_n}  y^{n\rightarrow m}_k\right) w_m^k s(d_k)\leq C_m, \\ \forall  m \in \mathcal{M}.
\end{aligned}$$

When MEC server $m$ does not have enough cache storage to cache data $d_k$, MEC server $m$ checks its RAT, and offloads $d_k$ to MEC server $n$ in the collaboration space (if MEC server $n$ has enough cache storage to satisfy the demand) or forwards the request to the DC. When data $d_k$ is requested at MEC server $m$, it will either be served from a cache in the collaboration space or forwarded to the DC if $d_k$ is not cached in the collaboration space.

Distributed Optimization Control {#subsec:control_model}
--------------------------------

Next, we propose a distributed control model, which is based on a distributed optimization that coordinates and integrates the communication, computation, and caching models defined in the previous sections.

In the distributed control model, we maximize the backhaul bandwidth saving (minimize the backhaul bandwidth) by reducing the data exchange between MEC servers and remote DC, i.e., increasing the cache hits. Therefore, we adopt the caching reward defined in @wang2017computation as the amount of saved backhaul bandwidth given by: $$\begin{aligned}
\Psi({{\boldsymbol{x}},{\boldsymbol{y}}, {\boldsymbol{w}}})= \sum_{m\in \mathcal{M}}\sum_{k\in \mathcal{K}_m} s(d_k)\lambda^{d_k}_m  x^m_k(y_k^{k\rightarrow m}  w_m^{k} \\+\sum_{n\in \mathcal{M}}y^{m\rightarrow n}_k w_n^k),
\end{aligned}
\label{eq:caching_reward}$$ where the requests for data $d_k$ arrive at BS $m$ with arrival rate $\lambda^{d_k}_m$.

Here, we consider the total delay as the total amount of time that task $T_{k}$ takes to be completely computed (offloading delay included). For the computation cost, if user $k$ computes its task locally, then the computational delay cost of $\tau^\textrm{loc}_k$ is incurred. On the other hand, when user $k$ decides to offload the computational task to an MEC server, a total offloading and computation delay of $\tau^\textrm{off}_{k}$ is incurred. In order to minimize both computation delay costs ($\tau^\textrm{loc}_{k}$ and $\tau^\textrm{off}_{k}$), we formulate the total delay $\Theta({\boldsymbol{x}},{\boldsymbol{y}})$ for the tasks computed locally at user devices, or in the MEC collaboration space, or at the remote cloud as follows: $$\begin{aligned}
&\Theta({\boldsymbol{x}},{\boldsymbol{y}})=\sum_{m\in \mathcal{M}}\sum_{k\in \mathcal{K}_m} (1-x_k^m)\tau^\textrm{loc}_{k} +x_k^m\tau^\textrm{off}_{k}.
\end{aligned}
\label{eq:total_compution_cost}$$

### Problem Formulation

We formulate the joint 4C in big data MEC as an optimization problem that aims at maximizing bandwidth saving while minimizing delay, subject to the local computation capabilities of user devices, and MEC resource constraints as follows:

\[eq:problem\_formulation\] $$\begin{aligned}
    &\underset{{\boldsymbol{x}}, {\boldsymbol{y}}, {\boldsymbol{w}}}{\text{min}}\ \  \Theta({\boldsymbol{x}},{\boldsymbol{y}})-\eta \Psi({{\boldsymbol{x}},{\boldsymbol{y}}, {\boldsymbol{w}}})
    \tag{\ref{eq:problem_formulation}}\\
    &\text{subject to:}\nonumber\\
    & \sum_{k\in \mathcal{K}_m}x_k^ma^m_{k}\leq 1, \;  \forall m \in \mathcal{M},\label{first:a}\\
    &\sum_{k\in \mathcal{K}_m}x_k^mp_{km}y_k^{k\rightarrow m}\leq P_m,\forall  m \in \mathcal{M}, \label{first:b}\\
    &x_k^m (\sum_{k\in \mathcal{K}_m} y^{k \rightarrow m} + \sum_{n\neq m\in \mathcal{M}}\sum_{k\in \mathcal{K}_n}  y^{n\rightarrow m}_k) w_m^k s(d_k)\leq C_m, \label{first:c}\\
    &(1-x^m_k) + x^m_k(y_k^{k\rightarrow m}+\sum_{n\in \mathcal{M}}y^{m\rightarrow n}_k + y^{m\rightarrow DC}_k)= 1, \label{first:d}\\
    &\max \{y_k^{k\rightarrow m}, y^{m\rightarrow n}_k, y^{m\rightarrow DC}_k,\forall n  \}\leq x^m_k,\label{first:e}
    \end{aligned}$$

where $\eta>0$ is the weight parameter, which is typically used in multi-objective optimization @deb2014multi.

The constraint in (\[first:a\]) guarantees that the sum of spectrum allocation to all users has to be less than or equal to the total available spectrum at each BS $m$. The constraints in (\[first:b\]) and (\[first:c\]) guarantee that the computation and cache resources allocated to users at each MEC server $m$ do not exceed the computation and caching resources. The constraints in (\[first:d\]) and (\[first:e\]) ensure that the task $T_k$ has to be executed at only one location, i.e., no duplication. Furthermore, in order to simplify the notation, we define the new objective function: $$\begin{aligned}
\mathcal{B}({{\boldsymbol{x}},{\boldsymbol{y}},{\boldsymbol{w}}}){\mathrel{\vcenter{\baselineskip0.5ex \lineskiplimit0pt
            \hbox{\scriptsize.}\hbox{\scriptsize.}}}    =}\Theta({\boldsymbol{x}},{\boldsymbol{y}})-\eta\Psi({{\boldsymbol{x}},{\boldsymbol{y}}, {\boldsymbol{w}}}).
\end{aligned}
\label{eq:transformed_equation}$$

The above optimization problem in (\[eq:transformed\_equation\]) is difficult to solve due to its non-convex structure. Therefore, to make it convex, we use BSUM method described in below Section \[subsubsec:BSUM\].

### Overview of BSUM Method {#subsubsec:BSUM}

BSUM is a distributed algorithm that allows parallel computing. The advantages of BSUM over centralized algorithms reside in both solution speed and problem decomposability @han2017signal. Therefore, for introducing BSUM @hong2016unified in its standard form, we consider the following function as a block-structured optimization problem: $$\begin{aligned}
\underset{{\boldsymbol{x}}}{\text{min}} \;g({{\boldsymbol{x}}_1,{\boldsymbol{x}}_2,\ldots,{\boldsymbol{x}}_J}), \; s.t. \; {\boldsymbol{x}}_j \in \mathcal{Z}_j,\;\forall j \in \mathcal{J}^t,\; j=1,\ldots,J,
\end{aligned}
\label{eq:optimization_bsum}$$ where $\mathcal{Z}:=\mathcal{Z}_1  \times \mathcal{Z}_2 \times \cdots \mathcal{Z}_J$, $g(.)$ is a continuous function, and $\mathcal{J}^t$ is the set of indexes. For $j=1,\ldots,J$, we consider $\mathcal{Z}_j$ as a closed convex set, and ${\boldsymbol{x}}_j$ as a block of variables. By applying BCD, at each iteration $t$, a single block of variables is optimized by solving the following problem: $$\begin{aligned}
{\boldsymbol{x}}^t_j \in \underset{{\boldsymbol{x}}_j \in \mathcal{Z}_j}{\text{argmin}}\; g({{\boldsymbol{x}}_j, \;{\boldsymbol{x}}^{t-1}_{-j}}),
\end{aligned}
\label{eq:optimization_BCD}$$ where ${\boldsymbol{x}}^{t-1}_{-j}:=(x^{t-1}_{1},\ldots, x^{t-1}_{j-1},x^{t-1}_{j+1},\ldots, x^{t-1}_{j}$), ${\boldsymbol{x}}^{t}_{k}={\boldsymbol{x}}^{t-1}_{k}$ for $j\neq k$.

Both problems in (\[eq:optimization\_bsum\]) and (\[eq:optimization\_BCD\]) are difficult to solve, especially when (\[eq:optimization\_bsum\]) is a non-convex function, and block coordinate descent (BCD) does not always guarantee convergence. Therefore, with BSUM, at a given feasible point ${\boldsymbol{y}} \in \mathcal{Z}$, we can introduce the proximal upper-bound function $h({\boldsymbol{x}}_j,{\boldsymbol{y}})$ of $g({\boldsymbol{x}}_j,{\boldsymbol{y}}_{-j})$. The most commonly used schemes for choosing the proximal upper-bound function are proximal upper-bound, quadratic upper-bound, linear upper-bound and Jensen's upper-bound @hong2016unified. The proximal upper-bound function $h({\boldsymbol{x}}_j,{\boldsymbol{y}})$ must satisfy following Assumption $1$:

\[1\]\
<span>  </span>\[1A\] $h({\boldsymbol{x}}_j,{\boldsymbol{y}})=g({\boldsymbol{y}})$,\
<span>  </span>\[1B\] $h({\boldsymbol{x}}_j,{\boldsymbol{y}})>g({\boldsymbol{x}}_j,{\boldsymbol{y}}_{-j})$,\
<span>  </span>\[1C\] $h'({\boldsymbol{x}}_j,{\boldsymbol{y}};{\boldsymbol{q}}_j)|_{{\boldsymbol{x}}_j={\boldsymbol{y_j}}}=g'({\boldsymbol{y}}; {\boldsymbol{q}}), \;{\boldsymbol{y}}_j+{\boldsymbol{q}}_j \in \mathcal{Z}_j $.

Assumptions \[1A\] and \[1B\] guarantee that the proximal upper-bound function $h$ must be a global upper-bound function of the objective function $g$. Furthermore, Assumption \[1C\] guarantee that $h({\boldsymbol{x}}_j,{\boldsymbol{y}})$ takes steps proportional to the negative of the gradient of the objective function $g({\boldsymbol{x}}_j,{\boldsymbol{y}}_{-j})$ in the direction ${\boldsymbol{q}}$, i.e., the existence of first-order derivative behavior.

For ease of presentation, we use the following proximal upper-bound, where the upper-bound is constructed through adding quadratic penalization to the objective function: $$\begin{aligned}
h({\boldsymbol{x_j}},{\boldsymbol{y}})=g({\boldsymbol{x}}_j,{\boldsymbol{y}}_{-j})+\frac{ \varrho}{2} ({{\boldsymbol{x}}_j-{\boldsymbol{y}}_j })^2,
\end{aligned}
\label{eq:approximation_BCD}$$ where $\varrho$ is a positive penalty parameter.

At each iteration $t$, the BSUM solves the proximal upper-bound function via the following update: $$\begin{cases}
&{\boldsymbol{x}}^t_j \in \underset{{\boldsymbol{x}}_j \in \mathcal{Z}_j}{\text{argmin}}\; h({{\boldsymbol{x}}_j, {\boldsymbol{x}}_j^{t-1}}),\; \forall j \in \mathcal{J}^t,\\
& {\boldsymbol{x}}^{t}_k={\boldsymbol{x}}^{t-1}_k, \; \forall k \notin  \mathcal{J}^t.
\end{cases}
\label{eq:optimization_bsum_update}$$ There are many selection rules that can be used for selecting each coordinate $j \in \mathcal{J}^t$ at each iteration $t$, such as Cyclic, Gauss-Southwell, and Randomize @hong2016unified. The complete structure of the BSUM algorithm is described in Algorithm \[algo:BSUM\].

\[H\]

\[1\] ;\

Algorithm \[algo:BSUM\] (BSUM) can be considered as a generalized form of BCD that optimizes block by block the upper-bound function of the original objective function. BSUM can be used for solving separable smooth or non-smooth convex optimization problems that have linear coupling constraints. To solve the family of such problems, the BSUM updates each block of variables iteratively through minimizing the proximal upper-bound function until it converges to both a coordinate-wise minimum and a stationary solution. We consider the stationary solution to be a coordinate-wise minimum, when a block of variables reaches the minimum point ${\boldsymbol{x}}^*={\boldsymbol{x}}_j^{(t+1)}$. In other words, at stationary points, the entire vector of points cannot find a better minimum direction @hong2016unified [@hong2014block]. Based on @hong2016unified and @hong2017iteration, we can make the following remark:

\[Convergence\] BSUM algorithm takes $\mathcal{O}\left(\log(1/\epsilon)\right)$ to converge to an $\epsilon$-optimal solution, which is sub-linear convergence.

The $\epsilon$-optimal solution ${\boldsymbol{x}}^\epsilon_j \in \mathcal{Z}_j$ is defined as ${\boldsymbol{x}}^\epsilon_j \in \{{\boldsymbol{x}}_j|{\boldsymbol{x}}_j \in \mathcal{Z}_j, \;h({\boldsymbol{x}}_j,{\boldsymbol{x}}^t, {\boldsymbol{y}}^t)-h({\boldsymbol{x}}^*_j,{\boldsymbol{x}}^t, {\boldsymbol{y}}^t)\}\leq \epsilon$, where $h({\boldsymbol{x}}^*_j,{\boldsymbol{x}}^t, {\boldsymbol{y}}^t)$ is the optimal value of $h({\boldsymbol{x}}_j,{\boldsymbol{y}})$ with respect to ${\boldsymbol{x}}_j$.

### Distributed Optimization Control Algorithm {#subsubsec:BSUM_4C}

In our optimization problem in (\[eq:transformed\_equation\]) is difficult to solve due to the presence of decision variables that need to be used in different locations, and updating these variables one at a time is impractical. Therefore, we consider BSUM as a suitable candidate method for solving it in a distributed way by focusing on solving per-block subproblems. In order to apply BSUM in our distributed optimization control model, we define $\mathcal{X}\triangleq\{{\boldsymbol{x}}:\sum_{m \in \mathcal{M}}\sum_{k\in \mathcal{K}_m} x_k^m=1, x_k^m  \in [0,1]\}$, $\mathcal{Y}\triangleq\{{\boldsymbol{y}}:\sum_{m \in \mathcal{M}}\sum_{k\in \mathcal{K}_m} y_k^{k\rightarrow m} + y^{m\rightarrow n}_k +y^{m\rightarrow DC}_k=1, y_k^{k\rightarrow m} , y^{m\rightarrow n}_k , y^{m\rightarrow DC}_k  \in [ 0, 1]\}$, and $ \mathcal{W}\triangleq \{{\boldsymbol{w}}: \sum_{m \in \mathcal{M}}\sum_{k\in \mathcal{K}_m} w_m^k  + w_n^k + w_{DC}^k= 1 , w_m^k, w_n^k , w_{DC}^k  \in [0,1]\}$ as the feasible sets of ${\boldsymbol{x}}$, ${\boldsymbol{y}}$, and ${\boldsymbol{w}}$, respectively.

At each iteration $t$, $\forall j \in \mathcal{J}^t$, we define the proximal upper-bound function $B_j$, which is convex and the proximal upper-bound of the objective function defined in (\[eq:transformed\_equation\]). In order to guarantee that the proximal upper-bound function $B_j$ is convex, we add to the objective function in (\[eq:transformed\_equation\]) a quadratic penalization, as follows:

$$\begin{aligned}
\mathcal{B}_j({{\boldsymbol{x}}_j,{\boldsymbol{x}}^{(t)}, {\boldsymbol{y}}^{(t)}, {\boldsymbol{w}}^{(t)}}){\mathrel{\vcenter{\baselineskip0.5ex \lineskiplimit0pt
            \hbox{\scriptsize.}\hbox{\scriptsize.}}}    =}\mathcal{B}{({\boldsymbol{x}}_j,{\boldsymbol{\tilde{x}}}, {\boldsymbol{\tilde{y}}}, {\boldsymbol{\tilde{w}}}}) + \frac{ \varrho_j}{2} \lVert({\boldsymbol{x}}_j- {\boldsymbol{\tilde{x}}})\rVert^2. 
\end{aligned}
\label{eq:optimization_bsum1}$$

(\[eq:optimization\_bsum1\]) is the proximal upper-bound function of (\[eq:transformed\_equation\]), and it can be applied to other vectors of variables ${\boldsymbol{y}}_j$ and ${\boldsymbol{w}}_j$, respectively, where $\varrho_t>0$ is the positive penalty parameter. Furthermore, the proximal upper-bound function in (\[eq:optimization\_bsum1\]) is a convex optimization problem due to its quadratic term $\frac{ \varrho_j}{2} \lVert({\boldsymbol{x}}_j- {\boldsymbol{\tilde{x}}})\rVert^2$. In other words, with respect to ${\boldsymbol{x}}_j$, ${\boldsymbol{y}}_j$, and ${\boldsymbol{w}}_j$, it has minimizers vector ${\boldsymbol{\tilde{x}}}$, ${\boldsymbol{\tilde{y}}}$, and ${\boldsymbol{\tilde{w}}}$ at each iteration $t$, which are considered to be the solution of the previous step ($t-1$). At each iteration $t+1$, the solution is updated by solving the following optimization problems: $$\begin{aligned}
{\boldsymbol{x}}_j^{(t+1)}\in \underset{ {\boldsymbol{x}}_j \in \mathcal{X}}{\text{min}}\; \mathcal{B}_j ({\boldsymbol{x}}_j,{\boldsymbol{x}}^{(t)}, {\boldsymbol{y}}^{(t)}, {\boldsymbol{w}}^{(t)}),
\end{aligned}
\label{eq:optimization20}$$ $$\begin{aligned}
{\boldsymbol{y}}_j^{(t+1)}\in \underset{ {\boldsymbol{y}}_j \in \mathcal{Y}}{\text{min}}\; \mathcal{B}_j ({\boldsymbol{y}}_j,{\boldsymbol{y}}^{(t)}, {\boldsymbol{x}}^{(t+1)}, {\boldsymbol{w}}^{(t)}),
\end{aligned}
\label{eq:optimization21}$$ $$\begin{aligned}
{\boldsymbol{w}}_j^{(t+1)}\in \underset{ {\boldsymbol{w}}_j \in \mathcal{W}}{\text{min}}\; \mathcal{B}_j ({\boldsymbol{w}}_j,{\boldsymbol{w}}^{(t)}, {\boldsymbol{x}}^{(t+1)}, {\boldsymbol{y}}^{(t+1)}).
\end{aligned}
\label{eq:optimization22}$$

Furthermore, (\[eq:optimization20\]), (\[eq:optimization21\]), and (\[eq:optimization22\]) can be solved through the use of our proposed distributed optimization control presented in Algorithm \[algo:onlienalgorithm\] for 4C, which is a modified version of the standard BSUM (Algorithm \[algo:BSUM\]). For solving (\[eq:optimization20\]), (\[eq:optimization21\]), and (\[eq:optimization22\]), we relax the vectors of variables ${\boldsymbol{x}}_j$, ${\boldsymbol{y}}_j$, and ${\boldsymbol{w}}_j$ taking values in the closed interval between $0$ and $1$. Then, we use a threshold rounding technique described in @feige2016oblivious in Algorithm \[algo:onlienalgorithm\] to enforce the relaxed ${\boldsymbol{x}}_j$, ${\boldsymbol{y}}_j$, and ${\boldsymbol{w}}_j$ to be vectors of binary variables.

As an example, in the rounding technique, for $x_k^{m*}  \in {\boldsymbol{x}}_j^{(t+1)}$, $x_k^{m*} \geq \theta$, where $\theta \in (0,1)$ is a positive rounding threshold, we set $x_k^{m*}$ as follows:

$$\label{eq:b_rounding}
\setlength{\jot}{10pt}
x_k^{m*} =
\begin{cases}
1,\; \text{if $x_k^{m*} \geq \theta$},\\
0, \;\text{otherwise.}
\end{cases}$$

The above rounding technique can be applied to other vectors of variables ${\boldsymbol{y}}_j$ and ${\boldsymbol{w}}_j$, respectively. However, the binary solution obtained from the rounding technique may violate communication, computational, and caching resource constraints. Therefore, as described in @zhang2017network, to overcome this issue after rounding, we solve the problem (\[eq:optimization\_bsum1\]) in the form of $\mathcal{B}_j + \xi \Delta$, where constraints $(\ref{first:a})$, $(\ref{first:b})$, and $(\ref{first:c})$ are modified as follows: $$\sum_{k\in \mathcal{K}_m}x_k^ma^m_{k}\leq 1 + \Delta_a, \;  \forall m \in \mathcal{M},\label{first:a_m}$$ $$\label{first:b_m}
\sum_{k\in \mathcal{K}_m}x_k^mp_{km}y_k^{k\rightarrow m}\leq P_m + \Delta_p,\forall  m \in \mathcal{M},$$ $$\label{first:c_m}
x_k^m (\sum_{k\in \mathcal{K}_m} y^{k \rightarrow m} + \sum_{n\neq m\in \mathcal{M}}\sum_{k\in \mathcal{K}_n}  y^{n\rightarrow m}_k) w_m^k s(d_k)\leq C_m + \Delta_m,$$ where $\Delta_a$ is the maximum violation of communication resources constraint, $\Delta_p$ is the maximum violation of computational resources constraint, $\Delta_m$ is the maximum violation of caching resources constraint, $\Delta= \Delta_a + \Delta_p + \Delta_m$, and $\xi$ is the weight of $\Delta$. Moreover, $\Delta_a$, $\Delta_p$, and $\Delta_m$ are given by: $$\label{eq:rounding-10}
\Delta_a =\max \{ 0,\sum_{k\in \mathcal{K}_m}x_k^ma^m_{k} - 1 \},\;\forall  m \in \mathcal{M},$$ $$\label{eq:rounding-11}
\Delta_p = \max \{0, \sum_{k\in \mathcal{K}_m}x_k^mp_{km}y_k^{k\rightarrow m} - P_m  \},\;\forall  m \in \mathcal{M},$$ $$\begin{gathered}
\label{eq:rounding-22}
\Delta_m =\max \{0, x_k^m (\sum_{k\in \mathcal{K}_m} y^{k \rightarrow m} + \sum_{n\neq m\in \mathcal{M}}\sum_{k\in \mathcal{K}_n}  y^{n\rightarrow m}_k) w_m^k s(d_k)\\- C_m  \}.\end{gathered}$$ Furthermore, if there are no violations of communication, computational, and caching resources constraints ($\Delta_a=0$, $\Delta_p=0$, and $\Delta_m=0$), the feasible solution of (\[eq:optimization\_bsum1\]) is obtained.

\[Integrality gap\] Given problem $\mathcal{B}_j$ (\[eq:optimization\_bsum1\]) and its rounded problem $\mathcal{B}_j + \xi \Delta$, the integrality gap is given by:

In Algorithm \[algo:onlienalgorithm\] for 4C, each user device $k \in \mathcal{K}$ chooses the offloading decision $x_k^m$. If $x_k^m=1$, the user sends its demands to the nearest BS. For each demand $T_{k}$ received, the BS checks its RAT for its own and collaboration space resource availabilities. Algorithm \[algo:onlienalgorithm\] starts by initializing $t=0$, and setting $\epsilon$ equal to a small positive number, where $\epsilon$ is used to guarantee the $\epsilon$-optimal solution defined in @hong2016unified. Algorithm \[algo:onlienalgorithm\] then finds the initial feasible points (${\boldsymbol{x}}^{(0)}$, ${\boldsymbol{y}}^{(0)}$, ${\boldsymbol{w}}^{(0)}$). Subsequently, our algorithm starts an iterative process and chooses the index set. At each iteration $t+1$, the solution is updated by solving the optimization problems (\[eq:optimization20\]), (\[eq:optimization21\]), and (\[eq:optimization22\]) until $\frac{\mathcal{B}_j^{(t)}-\mathcal{B}_j^{(t+1)}}{\mathcal{B}_j^{(t)}} \leq \epsilon $. Algorithm \[algo:onlienalgorithm\] generates a binary solution of ${\boldsymbol{x}}_j^{(t+1)}$, ${\boldsymbol{y}}_j^{(t+1)}$, and ${\boldsymbol{w}}_j^{(t+1)}$ via the rounding technique (\[eq:b\_rounding\]), solves $\mathcal{B}_j + \xi \Delta$, and calculates $\beta$ for obtaining ${\boldsymbol{c}}$, ${\boldsymbol{p}}$, and ${\boldsymbol{R}}$. Furthermore, ${\boldsymbol{x}}^*={\boldsymbol{x}}_j^{(t+1)}$, ${\boldsymbol{y}}^*={\boldsymbol{y}}_j^{(t+1)}$, and ${\boldsymbol{w}}^*={\boldsymbol{w}}_j^{(t+1)}$ are considered to be stationary solution that satisfies coordinate-wise minimum. Finally, Algorithm 3 updates its RAT and sends the RAT update in its collaboration space.

\[t\]

\[1\] ;

The difference between the BSUM (Algorithm \[algo:BSUM\]) in its standard form and the BSUM for 4C in big data MEC (Algorithm \[algo:onlienalgorithm\]) resides in their implementations, where BSUM Algorithm in its standard form is based on distributed control. On the other hand, Algorithm \[algo:onlienalgorithm\] is based on both the hierarchical and distributed control models defined in @molzahn2017survey. In the hierarchical control model, edge devices decide on ${\boldsymbol{x}}$ first. Then, each MEC server $m$ acts as a controller for the users' offloaded tasks and, thus, it solves (\[eq:optimization20\]), (\[eq:optimization21\]), and (\[eq:optimization22\]).

In the distributed control model, each MEC server exchanges small information with other MEC servers in order to maintain the resource allocation within a tight range of available computational resources $P$ and caching resources $C$. However, in a collaboration space, there is no centralized controller that controls all MEC servers. This distributed control is modeled as a dynamic feedback control model described in @farivar2015local, where the RAT update at each MEC server acts as feedback with state $({\boldsymbol{x}}^{(t)},\;{\boldsymbol{y}}^{(t)},\; {\boldsymbol{w}}^{(t)})$ at iteration $t$, which is used to determine the new state $({\boldsymbol{x}}^{(t+1)},\;{\boldsymbol{y}}^{(t+1)}, \;{\boldsymbol{w}}^{(t+1)})$ at the next iteration $t+1$. Furthermore, the optimal value (${\boldsymbol{x}}^*_j, \;{\boldsymbol{y}}^*_j, \;{\boldsymbol{w}}^*_j$) is considered to be network equilibrium or a stability point, which is the stationary solution that satisfies a coordinate-wise minimum.

Simulation Results and Analysis {#sec:PE}
===============================

In this section, we present the performance evaluation of the proposed joint 4C in big data MEC, where the Python language @van2007python is used for numerical analysis.

Simulation Setup
----------------

For forming collaboration spaces, we use the Sitefinder dataset from Edinburgh DataShare @boswarva2017sitefinder. In this dataset, we randomly select one MNO, which has $12777$ BSs, through use of the OKM-CS algorithm for unsupervised machine learning, where we group these BSs into $1000$ collaboration spaces. Therefore, based on the BS locations and their proximities, the number of BSs in one collaboration space is in the range from $1$ BS to $203$ BSs. Among $1000$ collaboration spaces, we randomly select one collaboration space, which has $12$ BSs, and we associate each BS with $1$ MEC server. Furthermore, we consider the initial number of users to be $K=50$ at each BS. where each user sends one task at each time slot. The path loss factor is set to $4$ and the transmission power is set to $\rho_k=27.0$ dBm @zhou2017resource, while the channel bandwidth is set to be in the range from $B_m=25$ MHz to $B_m=32$ MHz @boswarva2017sitefinder. Furthermore, we consider the bandwidth between each pair of BSs to be randomly selected in the range from $\Gamma^n_m=20$ MHz to $\Gamma^n_m=25$ MHz, while the bandwidth between each BS and DC is selected in the range from $\Omega^{DC}_m=50$ to $\Omega^{DC}_m=120$ Mbps. The cache storage of each MEC server $m$ is in the range from $100$ to $500$ TB, while computation resources are in the range from $2$ GHz to $2.5$ ashleytorres@example.org.

For task $ T_{k}$ of a given user $k$, the size of data $s(d_k)$ is randomly generated in the range from $2$ to $7$ $GB$, while the task computation deadline $\tilde{\tau}_{k}$ is randomly generated in the range from $\tilde{\tau}_{k}=0.02$ second to $\tilde{\tau}_{k}=12$ seconds. The workload $z_k$ of each user device $k$ is randomly generated and uniformly distributed in the range from $z_k= 452.5$ cycles/bit to $z_k=737.5$ cycles/bit @mao2017stochastic. For each user device, the computation resource is in range from $0.5$ GHz to $1.0$ GHz @chen2016efficient. We consider that each end-user device has a CPU peak bandwidth of $16$-bit values per cycle, while each MEC server has a CPU peak bandwidth of 64-bit values per cycle.

At each time slot, we use $50$ different contents, where the total number of requests for contents ranges from $\lambda^{d_k}_m=578$ to $\lambda^{d_k}_m=3200$. The demand and popularity of the content follow Zipf distributions as described in @newman2005power [@ndikumana2017network].

Performance Metrics
-------------------

### Throughput

. We define the network throughput as a measurement of how many units of information that a network can handle for a given period of time @ndikumana2017novel [@ndikumana2015network], while computation throughput is defined as a measurement of how many units of tasks that a given MEC server can compute for a given period of time. Here, the network throughput is measured in terms of Mbps, while the computation throughput is measured in terms of million instructions per second (MIPS).

### Delay

In a collaboration space, each task $T_ {k} $ offloaded by the user device ends its journey at the server which has resources that can fulfill user demand. Then, the MEC server computes, caches, and returns the output of the computation to the user. Therefore, we consider the total delay as the time period between offloading task $T_ {k} $ and receiving the corresponding computation output.

### Cache Hit Ratio and Bandwidth-saving

We also evaluate the number of cache hits and misses. A cache hit, denoted $h^{d_k}_m \in \{  0, 1\}$, occurs when the requested content $d_k$ is retrieved from the cache storage available in a collaboration space at any BS $m$. Cache hit contributes to bandwidth saving defined in (\[eq:caching\_reward\]) as it reduces the data exchange between the collaboration space and the DC. On the other hand, a cache miss occurs when the requested content $d_k$ is not available in any cache storage in the collaboration space. The probability of a cache hit for content $d_k$ is expressed as follows: $$\begin{aligned}
P_{d_k} = \frac{\sum_{k\in \mathcal{K}}\sum_{m\in \mathcal{M}} h^{d_k}_m} {\sum_{k\in \mathcal{K}}\sum_{m\in \mathcal{M}} (h^{d_k}_m + (1 - h^{d_k}_m))},
\end{aligned}
\label{eq:zipf-distribution}$$ where $\sum_{k\in \mathcal{K}}\sum_{m\in \mathcal{M}} h^{d_k}_m$ is the total number of cache hits, and $\sum_{k\in \mathcal{K}}\sum_{m\in \mathcal{M}} (h^{d_k}_m + (1 - h^{d_k}_m))$ is the total number of cache hits plus the total number of cache misses.

Simulation Results
------------------

<span>0.45</span> ![Optimal value of $\mathcal{B}_j + \xi \Delta$ with different coordinate selection rules (after rounding).<span data-label="fig:Optimization_comparization2"></span>](Optimization_comparization1.eps "fig:"){width="1.0\columnwidth"}

<span>0.45</span> ![Optimal value of $\mathcal{B}_j + \xi \Delta$ with different coordinate selection rules (after rounding).<span data-label="fig:Optimization_comparization2"></span>](Optimization_comparization2.eps "fig:"){width="1.0\columnwidth"}

<span>0.45</span> ![CDF of computation throughput.<span data-label="fig:computation_allocation"></span>](comunication_allocation.eps "fig:"){width="1.0\columnwidth"}

<span>0.45</span> ![CDF of computation throughput.<span data-label="fig:computation_allocation"></span>](computation_allocation.eps "fig:"){width="1.0\columnwidth"}

<span>0.45</span> ![Normalized cache hits in collaboration space.<span data-label="fig:normalized_cache_hit1"></span>](latency.eps "fig:"){width="1.0\columnwidth"}

<span>0.45</span> ![Normalized cache hits in collaboration space.<span data-label="fig:normalized_cache_hit1"></span>](normalized_cache_hit1.eps "fig:"){width="1.0\columnwidth"}

<span>0.45</span> ![Utilization of MEC cache storages.<span data-label="fig:caching_allocation"></span>](Bandwidth-saving.eps "fig:"){width="1.0\columnwidth"}

<span>0.45</span> ![Utilization of MEC cache storages.<span data-label="fig:caching_allocation"></span>](caching_allocation.eps "fig:"){width="1.0\columnwidth"}

Fig. \[fig:Optimization\_comparization1\] combines both delay viewed as cost and bandwidth saving in one optimization problem in (\[eq:optimization\_bsum1\]). We solve the proximal upper-bound problem through use of distributed optimization control algorithm for 4C (Algorithm \[algo:onlienalgorithm\]) and CVXPY @diamond2016cvxpy (a Python-embedded modeling language for solving convex optimization problems). Furthermore, we compare the solution of our distributed optimization control algorithm with the solution computed via Douglas-Rachford splitting @themelis2017douglas without applying a rounding technique. Thus, our formulated problem in (\[eq:optimization\_bsum1\]) is decomposable. The Douglas-Rachford splitting method is used to decompose our problem into small subproblems, and address each subproblem separately.

Fig. \[fig:Optimization\_comparization1\] shows the convergence of our optimization problem without rounding. In this figure, we use the Douglas-Rachford splitting method @themelis2017douglas and our distributed control algorithm (Algorithm \[algo:onlienalgorithm\]) for solving (\[eq:optimization\_bsum1\]). In our distributed control algorithm, for choosing indexes in $(\ref{eq:optimization_bsum1})$, we use three coordinate selection rules: Cyclic, Gauss-Southwell, and Randomized @hong2016unified. Furthermore, for the quadratic term in ($\ref{eq:optimization_bsum1}$), we adjust the positive penalty parameter $\varrho_j$ within the range $0.2$ to $100$. From this figure, we can see that the performance of our distributed control algorithm and Douglas-Rachford splitting method is almost nearly the same. Therefore, as of iteration $53$, the proximal upper-bound problem in $(\ref{eq:optimization_bsum1})$ converges to both a coordinate-wise minimum and a stationary point, which is considered as a solution of $(\ref{eq:optimization_bsum1})$. In other words, we consider this minimum point as an optimal value and equilibrium/stability point of $\mathcal{B}_j$ ($\ref{eq:optimization_bsum1}$).

In Fig. \[fig:Optimization\_comparization2\], we apply the rounding technique to the results of Fig. \[fig:Optimization\_comparization1\] and solve $\mathcal{B}_j + \xi \Delta$, where we consider the positive rounding threshold to be $\theta=7$ and the weight of $\Delta$ to be $\xi=0.14285$. The simulation results in Fig. \[fig:Optimization\_comparization2\] ensure that the relaxed ${\boldsymbol{x}}_j$, ${\boldsymbol{y}}_j$, and ${\boldsymbol{w}}_j$ to be vectors of binary variables, and the rounding technique does not violate the computational and caching resource constraints while solving $\mathcal{B}_j + \xi \Delta$. Furthermore, the difference between Fig. \[fig:Optimization\_comparization1\] and Fig. \[fig:Optimization\_comparization2\] resides in the sizes of the problems ($\mathcal{B}_j$ and $\mathcal{B}_j + \xi \Delta$) and the step sizes needed for reaching the minimum point.

Fig. \[fig:computation\_allocation\] shows the cumulative distribution function (CDF) of the computational throughput. The simulation results show that the Cyclic selection rule in our distributed optimization control algorithm as well as the Douglas-Rachford splitting method require high computational resources, as the computational throughput for each MEC server can reach $1.55 \times 10^{6}$ MIPS. On the other hand, the Gauss-Southwell and Randomized selection rules use less computational resources, as the computational throughput for each MEC server can reach $0.78 \times 10^{6}$ MIPS.

We next examine the delay between offloading task $T_ {k} $ and receiving the corresponding computation output. Fig. \[fig:latency\] shows the total delay experienced by user demand $ T_{k}$, where the solid blue lines represent the median and the dashed black lines represent the arithmetic mean. In this figure, Cyc stands for Cyclic, G-S stands for Gauss-Southwell, Ran stands for Randomized, while D-R-S stands for Douglas-Rachford splitting. The results in this figure show that the mean of the delay varies from $\tilde{\tau}_{k}=0.077$ to $\tilde{\tau}_{k}=0.128$ seconds, which fulfills the task computation deadline described in the simulation setup. However, Cyclic and Douglas-Rachford splitting yield higher delay than others due to index selection (for Cyclic) and splitting (for Douglas-Rachford splitting), which require more time and computation resources. Furthermore, Douglas-Rachford splitting has a higher delay than BSUM coordinate selection rules.

Fig. \[fig:normalized\_cache\_hit1\] shows the normalized cache hits, where cache hit ratio $P_{d_k}$ is computed from (\[eq:zipf-distribution\]). From Fig. \[fig:normalized\_cache\_hit1\], we can see that the cache hit ratio increases with the Zipf exponent parameter $a$. When $a=1.0$, due to the increase in the number of demands for contents, many contents become popular, which results in a high cache hit ratio of $0.51\%$ of the total demands $\lambda^{d_k}_m$ from users. In the case of cache misses in collaboration space, the demands for contents need to be forwarded to the DC. Therefore, cache hits contribute to reducing the number of demands $\lambda^{d_k}_m$ for contents that need to be forwarded to the DC. Furthermore, using the number of demands $\lambda^{d_k}_m$ and the size of cached contents $d_k$ in collaboration space, we compute bandwidth-saving through the use of (\[eq:caching\_reward\]).

Fig. \[fig:Bandwidth-saving2\] shows the simulation results for bandwidth-saving in terms of Gigabytes (GB). In this figure, from the beginning, bandwidth-saving is nearly zero, and thus MEC server has to cache the contents first. In other words, MEC caching is based on content prefetching. Therefore, due to the increase in the number of cached contents and demands, the maximum bandwidth-saving of $0.82 \times 10^6$ GB is observed when $a=1.0$.

Fig. \[fig:caching\_allocation\] shows the total cache storage utilization in the collaboration space of $12$ MEC servers, where the cache storage utilization depends on the sizes of offloaded data and cache capacity constraints.

Conclusion {#sec:Conclusion}
==========

In this paper, we have proposed a joint communication, computation, caching, and control (4C) framework for big data MEC. In this framework, MEC servers collaborate to satisfy user demands. We have formulated the problem as an optimization problem that aims to achieve maximum bandwidth saving while minimizing delay, subject to the local computation capabilities of the user devices, computation deadline, and MEC resource constraints. Therefore, for solving the formulated optimization problem, we have proposed a distributed optimization control algorithm for 4C, which is a modified version of the BSUM method. We have compared the results from distributed optimization control algorithm with the results computed via the Douglas-Rachford splitting method. The simulation results from both methods have shown that our approach increases bandwidth saving and minimizes delay.

<span>9</span>

H. Jin, L. Su, D. Chen, K. Nahrstedt, and J. Xu, "Quality of information aware incentive mechanisms for mobile crowd sensing systems," in *Proceedings of the 16th ACM International Symposium on Mobile Ad Hoc Networking and Computing*. ACM, 22 - 25 Jun. 2015 (Hangzhou, China), pp. 167–176. S. Taylor, "10 predictions for the future of the internet of things," https://blogs.cisco.com/cle/10-predictions-for-thefuture-of-the-internet-of-things, \[Online; accessed 3 Feb. 2018\]. E. Zeydan, E. Bastug, M. Bennis, M. A. Kader, I. A. Karatepe, A. S. Er, and M. Debbah, "Big data caching for networking: Moving from cloud to edge," *IEEE Communications Magazine*, vol. 54, no. 9, pp. 36–42, 16 Sep. 2016. A. Ferdowsi, U. Challita, and W. Saad, "Deep learning for reliable mobile edge analytics in intelligent transportation systems," *arXiv preprint arXiv:1712.04135*, 12 Dec. 2017. Y. C. Hu, M. Patel, D. Sabella, N. Sprecher, and V. Young, "Mobile edge computing—a key technology towards 5G," *White Paper*, vol. 11, no. 11, pp. 1–16, 5 Sep. 2015. M. Patel, B. Naughton, C. Chan, N. Sprecher, S. Abeta, A. Neal et al., "Mobile-edge computing introductory technical white paper," *Paper, Mobile-edge Computing (MEC) Industry Initiative*, Sep. 2014. O. Semiari, W. Saad, S. Valentin, M. Bennis, and H. V. Poor, "Context-aware small cell networks: How social metrics improve wireless resource allocation," *IEEE Transactions on Wireless Communications*, vol. 14, no. 11, pp. 5927–5940, 13 Jul. 2015. T. X. Tran, A. Hajisami, P. Pandey, and D. Pompili, "Collaborative mobile edge computing in 5G networks: New paradigms, scenarios, and challenges," *IEEE Communications Magazine*, vol. 55, no. 4, pp. 54–61, 14 Apr. 2017. A. Ndikumana, S. Ullah, T. LeAnh, N. H. Tran, and C. S. Hong, "Collaborative cache allocation and computation offloading in mobile edge computing," in *Proceedings of 19th IEEE Asia-Pacific Network Operations and Management Symposium (APNOMS)*, 27-29 Sep. 2017 (Seoul, South Korea), pp. 366–369. K. Dutta and M. Jayapal, "Big data analytics for real time systems," in *Proceedings of Big Data analytics seminar*, 11 Nov. 2015 (RWTH Aachen University, Germany), pp. 1–13. E. Ahmed and M. H. Rehmani, "Mobile edge computing: opportunities, solutions, and challenges," *Future Generation Computer Systems*, vol. 70, May 2017. G. Cleuziou, "An extended version of the k-means method for overlapping clustering," in *Proceedings of the 19th IEEE International Conference on Pattern Recognition (ICPR)*, 08-11 Dec. 2008 (Tampa, FL, USA), pp. 1–4. Z. Han, M. Hong, and D.Wang, Signal processing and networking for big data applications. *Cambridge University Press*, 2017. E. Bastug, M. Bennis, E. Zeydan, M. A. Kader, I. A. Karatepe, A. S. Er, and M. Debbah, "Big data meets telcos: A proactive caching perspective," *Journal of Communications and Networks*, vol. 17, no. 6, pp. 549–557, Dec. 2015. M. Chen, U. Challita, W. Saad, C. Yin, and M. Debbah, "Machine learning for wireless networks with artificial intelligence: A tutorial on neural networks," *preprint arXiv:1710.02913*, 9 Oct. 2017. W. Fan, Y. Liu, B. Tang, F.Wu, and H. Zhang, "Terminalbooster: Collaborative computation offloading and data caching via smart base stations," *IEEE Wireless Communications Letters*, vol. 5, no. 6, pp. 612–615, 02 Sep. 2016. G. Lee, W. Saad, and M. Bennis, "An online secretary framework for fog network formation with minimal latency," *arXiv preprint arXiv:1702.05569*, 7 Apr. 2017. T. X. Tran, P. Pandey, A. Hajisami, and D. Pompili, "Collaborative multi-bitrate video caching and processing in mobile-edge computing networks," in *Proceedings of 13th IEEE Annual Conference on Wireless On-demand Network Systems and Services (WONS)*, 21-24 Feb. 2017 (Jackson, WY, USA), pp. 165–172. M. Chen, Y. Hao, M. Qiu, J. Song, D. Wu, and I. Humar, "Mobility-aware caching and computation offloading in 5G ultra-dense cellular networks," *Sensors*, vol. 16, no. 7, p. 974, 25 Jun. 2016. W. Jiang, G. Feng, and S. Qin, "Optimal cooperative content caching and delivery policy for heterogeneous cellular networks," *IEEE Transactions on Mobile Computing*, vol. 16, no. 5, pp. 1382–1393, 03 Aug. 2016. H. Hsu and K.-C. Chen, "A resource allocation perspective on caching to achieve low latency," *IEEE Communications Letters*, vol. 20, no. 1, pp. 145–148, 09 Nov. 2015. Z. Tan, X. Li, F. R. Yu, L. Chen, H. Ji, and V. C. Leung, "Joint access selection and resource allocation in cache-enabled HCNs with D2D communications," in *Proceedings of IEEE Wireless Communications and Networking Conference (WCNC)*, 19-22 Mar. 2017 (San Francisco, CA, USA), pp. 1–6. M. Chen, M. Mozaffari, W. Saad, C. Yin, M. Debbah, and C. S. Hong, "Caching in the sky: Proactive deployment of cache-enabled unmanned aerial vehicles for optimized quality-of-experience," *IEEE Journal on Selected Areas in Communications*, vol. 35, no. 5, pp. 1046–1061, 09 Mar. 2017. Y. Zhou, F. R. Yu, J. Chen, and Y. Kuo, "Resource allocation for information-centric virtualized heterogeneous networks with in-network caching and mobile edge computing," *IEEE Transactions on Vehicular Technology*, vol. 66, no. 12, pp. 11 339–11 351, 09 Aug. 2017. C. Wang, C. Liang, F. R. Yu, Q. Chen, and L. Tang, "Computation offloading and resource allocation in wireless cellular networks with mobile edge computing," *IEEE Transactions on Wireless Communications*, vol. 16, pp. 4924–4938, 16 May 2017. R. Huo, F. R. Yu, T. Huang, R. Xie, J. Liu, V. C. Leung, and Y. Liu, "Software defined networking, caching, and computing for green wireless networks," *IEEE Communications Magazine*, vol. 54, no. 11, pp. 185–193, 15 Nov. 2016. J. Chakareski, "VR/AR immersive communication: Caching, edge computing, and transmission trade-offs," in *Proceedings of the ACM Workshop on Virtual Reality and Augmented Reality Network*, 21-25 Aug. 2017 (Los Angeles, CA, USA), pp. 36–41. Y. Cui, W. He, C. Ni, C. Guo, and Z. Liu, "Energy-efficient resource allocation for cache-assisted mobile edge computing," *arXiv preprint arXiv:1708.04813*, Aug. 16, 2017. S. Baadel, F. Thabtah, and J. Lu, "Overlapping clustering: A review," in *Proceedings of IEEE Computing Conference*, 3-15 Jul. 2016 (London, UK), pp. 233–237. R. Kune, P. K. Konugurthi, A. Agarwal, R. R. Chillarige, and R. Buyya, "The anatomy of big data computing," *Software: Practice and Experience*, vol. 46, no. 1, pp. 79–105, Jan. 2016. T. Nguyen and M. Vojnovic, "Weighted proportional allocation," in *Proceedings of the ACM Joint International Conference on Measurement and Modeling of Computer Systems( SIGMETRICS)*, 07 - 11 Jun. 2011 (San Jose, CA, USA), pp. 173–184. S. Mosleh, L. Liu, and J. Zhang, "Proportional-fair resource allocation for coordinated multi-point transmission in lte-advanced," *IEEE Transactions on Wireless Communications*, vol. 15, no. 8, pp. 5355–5367, 21 Apr. 2016. L. Lei, D. Yuan, C. K. Ho, and S. Sun, "Joint optimization of power and channel allocation with non-orthogonal multiple access for 5G cellular systems," in *Proceedings of IEEE Global Communications Conference (GLOBECOM)*, 6-10 Dec. 2015 (San Diego, CA, USA), pp. 1–6. Y. Mao, C. You, J. Zhang, K. Huang, and K. B. Letaief, "A survey on mobile edge computing: The communication perspective," *IEEE Communications Surveys and Tutorials*, vol. 19, no. 4, pp. 2322– 2358, 25 Aug. 2017. C. B. Networks, "Backhauling x2," http://cbnl.com/resources/ backhauling-x2, \[Online; accessed 3 Feb. 2018\]. M. S. Elbamby, M. Bennis, and W. Saad, "Proactive edge computing in latency-constrained fog networks," in *Proceedings of IEEE European Conference on Networks and Communications (EuCNC)*, 12-15 Jun. 2017 (Oulu, Finland), pp. 1–6. D. Lee, J. Choi, J.-H. Kim, S. H. Noh, S. L. Min, Y. Cho, and C. S. Kim, "LRFU: A spectrum of policies that subsumes the least recently used and least frequently used policies," *IEEE Transactions on Computers*, vol. 50, no. 12, pp. 1352–1361, Dec. 2001. A. Ndikumana, S. Ullah, and C. S. Hong, "Scalable aggregation-based packet forwarding in content centric networking," in *Proceedings of the 18th IEEE Asia-Pacific Network Operations and Management Symposium (APNOMS)*, 10 Nov. 2016 (Kanazawa, Japan), pp. 1–4. K. Deb, "Multi-objective optimization," in *Search methodologies*. Springer, 09 Jul. 2013, pp. 403–449. M. Hong, M. Razaviyayn, Z.-Q. Luo, and J.-S. Pang, "A unified algorithmic framework for block-structured optimization involving big data: With applications in machine learning and signal processing," *IEEE Signal Processing Magazine*, vol. 33, no. 1, pp. 57–77, 25 Dec. 2015. M. Hong, T.-H. Chang, X. Wang, M. Razaviyayn, S. Ma, and Z.- Q. Luo, "A block successive upper bound minimization method of multipliers for linearly constrained convex optimization," *arXiv preprint arXiv:1401.7079*, 2014. M. Hong, X. Wang, M. Razaviyayn, and Z.-Q. Luo, "Iteration complexity analysis of block coordinate descent methods," *Mathematical Programming*, vol. 163, no. 1-2, pp. 85–114, May 2017. U. Feige, M. Feldman, and I. Talgam-Cohen, "Oblivious rounding and the integrality gap," in *Proceedings of the Leibniz International Proceedings in Informatics*, vol. 60. Schloss Dagstuhl- Leibniz-Zentrum fuer Informatik, 13-16 Dec. 2016. N. Zhang, Y.-F. Liu, H. Farmanbar, T.-H. Chang, M. Hong, and Z.-Q. Luo, "Network slicing for service-oriented networks under resource constraints," *IEEE Journal on Selected Areas in Communications*, vol. 35, no. 11, pp. 2512–2521, 05 Oct. 2017. D. K. Molzahn, F. Dörfler, H. Sandberg, S. H. Low, S. Chakrabarti, R. Baldick, and J. Lavaei, "A survey of distributed optimization and control algorithms for electric power systems," *IEEE Transactions on Smart Grid*, vol. 8, no. 6, pp. 2941–2962, 25 Jul. 2017. M. Farivar, X. Zho, and L. Che, "Local voltage control in distribution systems: An incremental control algorithm," in *Proceedings of International Conference on Smart Grid Communications (SmartGridComm)*. IEEE, 2-5 Nov. 2015 (Miami, FL, USA), pp. 732–737. G. Van Rossum et al., "Python programming language." in *Proceedings of USENIX Annual Technical Conference*, vol. 41, 17-22 Jun. 2007 (Santa Clara, CA, USA), p. 36. O. Boswarva et al., "Sitefinder mobile phone base station database," *Edinburgh DataShare*, Feb. 2017. Y. Mao, J. Zhang, S. Song, and K. B. Letaief, "Stochastic joint radio and computational resource management for multi-user mobile-edge computing systems," *IEEE Transactions on Wireless Communications*, vol. 16, no. 9, pp. 5994–6009, 23 Jun. 2017. X. Chen, L. Jiao, W. Li, and X. Fu, "Efficient multi-user computation offloading for mobile-edge cloud computing," IEEE/ACM *Transactions on Networking*, vol. 24, no. 5, pp. 2795–2808, 26 Oct. 2015. M. E. Newman, "Power laws, pareto distributions and zipf's law," *Contemporary Physics*, vol. 46, no. 5, pp. 323–351, 20 Feb. 2007. A. Ndikumana, K. Thar, T. M. Ho, N. H. Tran, P. L. Vo, D. Niyato, and C. S. Hong, "In-network caching for paid contents in content centric networking," in *Proceedings of IEEE Global Communications Conference (GLOBECOM)*, 4-8 Dec. 2017 (Singapore), pp. 1–6. A. Ndikumana, S. Ullah, K. Thar, N. H. Tran, B. J. Park, and C. S. Hong, "Novel cooperative and fully-distributed congestion control mechanism for content centric networking," *IEEE Access*, vol. 5, pp. 4506952591, 29 Nov. 2017. A. Ndikumana, S. Ullah, R. Kamal, K. Thar, H. S. Kang, S. I. Moon, and C. S. Hong, "Network-assisted congestion control for information centric networking," in *Proceedings of 17th IEEE Asia-Pacific Network Operations and Management Symposium (APNOMS)*, 19-21 Aug. 2015 (Busan, South Korea), pp. 464–467. S. Diamond and S. Boyd, "Cvxpy: A python-embedded modeling language for convex optimization," *The Journal of Machine Learning Research*, vol. 17, no. 1, pp. 2909–2913, Apr. 2016. A. Themelis, L. Stella, and P. Patrinos, "Douglas-rachford splitting and ADMM for nonconvex optimization: new convergence results and accelerated versions," *arXiv preprint arXiv:1709.05747v2*, 9 Jan. 2018.

[^1]: Anselme Ndikumana, Nguyen H. Tran, Tai Manh Ho, and Choong Seon Hong are with the Department of Computer Science and Engineering, Kyung Hee University, Yongin-si, Gyeonggi-do 17104, Rep. of Korea,\
    E-mail:<span>{anselme, nguyenth, hmtai, ashleytorres@example.org</span>

[^2]: Zhu Han is with the Electrical and Computer Engineering Department, University of Houston, Houston, TX 77004, USA, and the Department of Computer Science and Engineering, Kyung Hee University, Yongin-si, Gyeonggi-do 17104, Rep. of Korea, E-mail:<span> {ashleytorres@example.org</span>

[^3]: Walid Saad is with the Bradley Department of Electrical and Computer Engineering, Virginia Tech, Blacksburg, USA, and the Department of Computer Science and Engineering, Kyung Hee University, Rep. of Korea, E-mail: <span>{ashleytorres@example.org</span>

[^4]: Dusit Niyato is with the School of Computer Engineering, Nanyang Technological University (NTU), Singapore, E-mail: <span>{ashleytorres@example.org</span>

{'source': 'arXiv_out/1803'}