Offloading and Resource Allocation in Mobile Edge

Offloading and Resource Allocation in Mobile Edge Computingwith Multiple Computing Access Points

by

Eric Jiang

A thesis submitted in conformity with the requirementsfor the degree of Master of Applied Science

Graduate Department of Electrical and Computer EngineeringUniversity of Toronto

c© Copyright 2019 by Eric Jiang

Abstract

Offloading and Resource Allocation in Mobile Edge Computing

with Multiple Computing Access Points

Eric Jiang

Master of Applied Science

Graduate Department of Electrical and Computer Engineering

University of Toronto

2019

In this thesis, we analyze three-tier mobile offloading networks consisting of multiple mobile devices, each

with a single task to be processed, multiple computing access points for possible task offloading, and

a remote cloud server as an additional possible offloading site. Our objective is to produce offloading

and resource allocation decisions that minimize the system cost, while achieving stability under the

assumption of selfish users. We first consider a centralized optimization approach under a strictly

defined objective function, using semidefinite relaxation to develop a heuristic solution that performs

nearly optimally under simulation. We then use that solution as an initial starting point to computing

the Nash equilibrium, exploiting the potential game property of that particular system. We then develop

a solution method to compute the optimal correlated equilibrium, which is applicable under a wider range

of system models and also meets the necessary stability requirements while minimizing the system cost.

ii

Acknowledgements

The completion of this thesis and my Master’s degree has been a journey that I could not have completed

alone. First and foremost, I would like to thank my supervisor Prof. Ben Liang for his mentorship and

support throughout my graduate studies. This thesis is a product of the many hours of discussion and

feedback we have had, through which I have learned tremendously and gained invaluable experience in

critical thinking, writing, and presentation that I will continue to apply through the rest of my life.

I also thank my defense committee, Prof. Alberto Leon-Garcia and Prof. Jorg Liebeherr, and the

chair, Prof. Lacra Pavel, for their time and efforts in reading and assessing my thesis and helping me

improve it with their feedback.

I would also like to thank all of the current and former members of our research group, whose

comments and feedback I have benefited from throughout my studies. Special thanks to Meng-Hsi Chen

and Prof. Min Dong, whose previous work serves as a foundation for much of my work here.

I wish to thank my friends, here in Toronto and elsewhere, for the support and encouragement they

have given me over these past two years. In particular, I thank my (soon to be) former roommates Kevin

Li and Jeffrey Peng for the continual friendship and emotional support they have given me, especially

during my hardest times.

Finally, I thank my family, my parents Dazhi and Cathy Jiang, and my sister Lillian, who have

supported me through my whole life and will continue to support me as I continue from my studies.

None of this would be possible without them.

iii

Contents

1 Introduction 1

1.1 The Offloading Problem under Multiple CAPs and Selfish Users . . . . . . . . . . . . . . . 2

1.2 Summary of Contribution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

1.2.1 Joint Centralized Optimization of Offloading Decisions and Resource Allocation . 3

1.2.2 Socially Optimal Correlated Equilibrium of Offloading Decisions . . . . . . . . . . 4

1.3 Related Works . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

1.4 Thesis Organization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2 Joint Centralized Optimization of Offloading Decisions and Resource Allocation 8

2.1 System Model and Centralized Optimization . . . . . . . . . . . . . . . . . . . . . . . . . 8

2.1.1 Offloading Decision . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

2.1.2 Cost of Local Processing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

2.1.3 Cost of CAP Processing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

2.1.4 Cost of Cloud Processing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

2.1.5 Optimization Problem Formulation . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

2.2 MCAP Offloading Solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

2.2.1 QCQP Formulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

2.2.2 SDP Solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

2.3 Selfish User Assumption . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

2.3.1 Game Formulation and Properties . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

2.3.2 MCAP-NE Offloading Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

2.4 Simulation Results . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

2.4.1 Default Parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

2.4.2 Impact of Different Parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

2.4.3 Placement Constraints . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

2.5 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

3 Socially Optimal Correlated Equilibrium of Offloading Decisions 30

3.1 System Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

3.1.1 Offloading Decision . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

3.1.2 Local Processing and Task Parameters . . . . . . . . . . . . . . . . . . . . . . . . . 31

3.1.3 CAP Processing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

3.1.4 Cloud Processing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

3.1.5 Individual and Social Cost Functions . . . . . . . . . . . . . . . . . . . . . . . . . . 33

iv

3.1.6 User Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

3.2 Class-Anonymous Offloading Game . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

3.2.1 Offloading Game . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

3.2.2 Correlated Equilibra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

3.2.3 Reduced Form of the Class-Anonymous Game . . . . . . . . . . . . . . . . . . . . . 37

3.3 Optimal Correlated Equilibrium Solution . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

3.3.1 Linear Programming Solution to Offloading Game . . . . . . . . . . . . . . . . . . 39

3.3.2 Resource Allocation Problem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

3.3.3 Distributed Computation by ADMM . . . . . . . . . . . . . . . . . . . . . . . . . . 43

3.4 Simulation Results . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

3.4.1 Multi-CAP System Results . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

3.4.2 MCAP Comparison . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

3.5 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

4 Conclusion 50

Bibliography 51

v

List of Tables

2.1 Parameters and Respective Descriptions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

2.2 Default Simulation Parameter Values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

3.1 Global Parameter Values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

3.2 Class Parameter Values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

3.3 Global Parameter Values - MCAP Comparison . . . . . . . . . . . . . . . . . . . . . . . . 47

vi

List of Figures

1.1 Mobile cloud system with CAPs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

2.1 Impact of the number of CAPs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

2.2 Impact of number of users . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

2.3 Impact of α . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

2.4 Impact of β . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

2.5 Cost against the number of users with placement constraints . . . . . . . . . . . . . . . . 28

2.6 Cost with placement constraints and without placement constraints . . . . . . . . . . . . 28

3.1 Cost against number of users per class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

3.2 Cost against α . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

3.3 Cost against number of CAPs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

3.4 Class costs against number of users . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

3.5 Cost against number of users—Comparison with MCAP . . . . . . . . . . . . . . . . . . . 49

vii

Chapter 1

Introduction

With the ever-increasing demand for computational resources by mobile applications, from a variety of

tasks including machine learning, virtual reality, and natural language processing, there is a growing

need for accessible computational resources in mobile networks that are available for task offloading [1].

Mobile Cloud Computing (MCC) would allow mobile devices to offload tasks to large remote data centres

in the cloud, such as Amazon EC2 [2]. This promises to improve the performance of demanding mobile

applications and expand the computational capabilities of mobile devices for future applications.

However, MCC systems may cause high latency for these mobile users, due to the transmission delays

required to wirelessly offloading tasks through long distances in order to reach the remote server. This

can prove fatal in providing adequate quality of service of many applications, especially computationally-

intensive real-time ones such as virtual reality. One means of resolving this is by providing additional

wireless and/or computational resources at the edge of the mobile system, such as the wireless base

station, thus giving the users faster access to the necessary resources [3], [4], [5]. Because base stations

have high-speed connections to the Internet and thus the various cloud servers, offloading through

these edge hosts could substantially reduce the transmission time and energy required to access these

servers. Additionally, base stations may hold their own servers, providing mobile users with an additional

site for possible task offloading. When computational resources are installed at or near radio access

networks, the system paradigm is known as Mobile Edge Computing (MEC), as defined by the European

Telecommunications Standards Institute (ETSI) [5]. However, other similar systems, such as micro cloud

centers, [6], cloudlets [7], and fog computing [8], use similar methods to reduce the communication latency

that result from MCC.

When these computing resources are built into a wireless access point or cellular base station, we refer

to it as a computing access point (CAP) [9], [10], [11], [12]. The CAP performs two functions—it serves

as a link between the individual mobile devices and the remote cloud server, whereby the application can

be forwarded through a high-speed connection, and it serves as an additional site for the computation

of the task itself, if doing so is more beneficial than local or remote processing. This is illustrated in

Figure 1.1.

1

Chapter 1. Introduction 2

1

N

1

M

Remote Cloudi

Figure 1.1: Mobile cloud system with CAPs

1.1 The Offloading Problem under Multiple CAPs and Selfish

Users

One research problem that arises from MCC and MEC systems is that of the offloading decision—

how to determine whether a task should be executed on the user’s mobile device, or offloaded to the

available edge or cloud servers [4]. Additionally, the available bandwidth and computational resources

are limited, especially at the CAP—thus good system performance would require a judicious distribution

of these resources between the users. Ideally, the offloading decision and the resource allocation would be

jointly optimized in order to maximize the overall quality of service provided by the system to the users.

However, this is a difficult problem due to the multiple tiers of offloading available, the heterogeneous

resources that must be assigned, the asymmetrical nature of the system, and the need to optimize over a

set of binary offloading decisions, resulting in a mixed-integer programming problem that is non-convex

and difficult to solve.

In [9], a single CAP system with a remote cloud server was considered, with multiple users and

one atomic task per user to be offloaded per round. A centralized controller was designed to jointly

optimize the offloading decisions and resource allocation to minimize a weighted sum of the total energy

consumption and the time required to process all of the tasks (i.e. the round time). The problem

was formulated as a mixed-integer optimization problem, which was then reformulated as a semidefinite

program (SDP) under a rank constraint. By relaxing that rank constraint, a heuristic solution method

was developed using the solution of the relaxed SDP to generate a series of trial solutions, computing

the optimal resource allocation for each through a convex program, then choosing the set of decisions

that minimizes the social objective. This method was extended in [11] to consider the case of multiple

tasks per user in a round.

However, in practical systems, multiple CAPs are often simultaneously available to the users. This

added dimension in the solution space adds significant complexity to the offloading decision and resource

allocation decisions, especially since the computational capability of different CAPs, as well as the quality

of wireless access to them, can substantially differ. Furthermore, the centralized optimization model does

not account for any agency of the users in making these offloading decisions, who often exhibit selfish


behaviour in reality, where each individual user would choose the offloading site that minimizes their

own individual cost. In such cases, individual users would not have an incentive to follow the decisions

of the central controller, limiting the scope of [9].

A rational solution should account for strategic behaviour among the users that may result if in-

dividual users have agency over their offloading decisions. Such a solution should be stable, in that

no individual user should be able to decrease their individual cost by deviating from it; one means of

achieving this is through the Nash equilibrium (NE). In [13], a single-CAP system was analyzed using

game theory, and a method to compute a pure-strategy Nash equilibrium (PSNE) was presented using

the fact that the game had a potential function—this has been the approach used most typically in

previous game-theoretic analyses of mobile offloading systems, as explicated in Section 1.3. However,

most strategic games do not have a potential function, and in such cases do not necessarily possess

a PSNE [14]. This limits the applicability of those previous works to a set of special cases. While

all finite games (games with a finite set of strategy profiles) possess mixed-strategy Nash equilibria

(MSNE) [14], computation of such equilibria is in general a PPAD-complete problem that is likely hard

to solve if P 6= NP [15]. A preferable solution would be an equilibrium condition that is more general

than the Nash equilibrium and more easily computed in a wider range of systems, while maintaining the

advantages of Nash for systems with selfish users.

1.2 Summary of Contribution

In this thesis, we consider system models similar to those [9] and [13], where multiple mobile users each

have a single task per round, which can be processed at the user’s local device, at a remote cloud, or at

one of the CAPs. However, rather than a single CAP, we now allow for multiple CAPs, each having their

own available communication and computational resources that may be allocated to the offloading users.

Like in the previous works, our goal is to choose a set of offloading and resource allocation decisions

that minimizes the system cost or objective, while preferably maintaining an incentive for selfish users

to participate in the system.

1.2.1 Joint Centralized Optimization of Offloading Decisions and Resource

Allocation

In Chapter 2, we consider a system model using the social objective function of [9] and [13]—that is, a

weighted sum of the total energy consumption and the round time. This objective function arises from

the need of the users to both maintain their battery life and achieve fast performance in an intensive

mobile application such as virtual reality in a round-by-round scheduling system. We then formulate

the joint offloading and resource allocation problem as a mixed-integer program, and present a heuristic

solution method by relaxing the original problem to one that is feasibly solvable. We also note that

by adding the assumption of selfish users in this system and adopting the individual objective function

from [13], this system can also be analyzed as a potential game with the NE1 solution method directly

adopted from [13].

Our contributions are as follows:

1Unless otherwise stated, all future usages of “Nash equilibrium” or “NE” refer to the pure-strategy NE.


• We develop the MCAP heuristic by modelling the above optimization problem as a quadratically-

constrained quadratic program (QCQP), extending the single-CAP formulation in [9] to multiple

CAPs. To do so, we must make significant changes to the formulation in [9], particularly through

new objective variables and constraints to accommodate the additional dimension of offloading

possibilities. We also accommodate for the addition of placement constraints, which may prevent

a user from offloading their task through some CAPs. We then relax the problem by eliminating a

rank constraint to produce a semidefinite program (SDP), and use those results to probabilistically

produce a series of offloading decisions, following the work in [16]. We choose the decisions among

those trials that minimizes the system cost, computing the resource allocation through a convex

optimization.

• Assuming users have agency over their offloading decisions and adopt as their individual cost

function a weighted sum of their energy consumption and the round time, the NE solution method

from [13] directly applies to this system and can be proven using their theoretical results with

trivial modifications. However, due to the combinatorial nature of the finite improvement method

used in [13], solving for an NE may require substantial computational time. To reduce the number

of iterations required, we propose using a starting point that is closer to the optimal solution than a

randomly chosen one. We use MCAP to obtain such a starting point, which is then combined with

the finite improvement method to construct the MCAP-NE solution. Thus, MCAP-NE improves

on MCAP by further reducing the system cost and accounting for the agency of selfish users.

• Simulation results demonstrate the superiority of the SDP approach in MCAP over a random set

of offloading decisions, the further improvements from the game-theoretic approach in MCAP-NE,

the close proximity of these solutions to the optimal solution of the system, and the computational

improvements due to the MCAP starting point, under a wide range of parameter settings.

1.2.2 Socially Optimal Correlated Equilibrium of Offloading Decisions

In Chapter 3, we then consider a system model where individual users may heterogeneously adopt any

individual objective function that is convex and nondecreasing with respect to the energy consumption

and task completion time (the round time no longer being necessary to the objective), with a social

objective being defined as a weighted sum of the individual objectives. Such a system can no longer

be ensured to have a potential function, which may cause the computation of a PSNE or MSNE to be

impossible or difficult to compute respectively. To produce a solution method that nonetheless results

in stable conditions for selfish users, we use the correlated equilibrium (CE) [17]. In particular, the

advantages of using the CE over the NE are as follows:

• The CE is guaranteed to exist in any finite game (a game with a finite strategy space), and can

always be computed in such games by solving a linear feasibility program. Thus, we no longer

require the existence of a potential function to develop a solution method. Even in potential

games, solving for the CE requires polynomial time for a fixed number of users, while the finite

improvement method to computing an NE in a potential game requires exponential time, given

the combinatorial nature of that approach.

• A CE can achieve a lower expected social cost than an NE. Because the set of CE forms a convex

set, one can optimize over a convex function within the feasible set to find a CE that minimizes a


social objective. Because the NE is a subset of the CE [17], this optimal CE can improve on the

social cost of the NE.

However, the NE maintains certain advantages over the CE:

• The NE is a deterministic strategy, while the CE is a random distribution over the entire strategy

space.

• The NE can always be represented in linear space with respect to the number of users. The CE

however generally requires exponential space with respect to the number of users, since it is a

distribution over the entire set of strategy profiles in the system. Furthermore, computation of an

optimal CE generally requires exponential time with respect to the number of players [18]. This

can only be resolved under certain conditions where the game can be represented in a reduced

form.

• The NE exhibits stronger stability conditions than the CE, since the NE allows users to have full

knowledge of the strategies of the other users and can directly respond to them, while the CE only

allows users to respond to knowledge of a conditional distribution over the strategy space.

However, we make the practical assumption that users do not have and are unable to obtain direct

knowledge of the decisions of other users. This makes the stability conditions of the CE sufficient for

our system.

Our contributions are as follows:

• While finite games generally have a convex set of CE, our objective is to find the optimal CE with

respect to the social cost function. We thus make the assumption that the users in the system

can be grouped into classes, whereby users within each class share identical distributions of their

task and wireless parameters and similar mobile device characteristics. Under that assumption, we

analyze the system as a class-anonymous (CA) game, where the users have no reason to distinguish

other users within the same class when making their offloading decisions. We prove by deriving

a reduced form of the CA game that as long as the number of classes in the system is fixed, an

optimal CE can be found in polynomial time with respect to the number of users, and represented

in polynomial space.

• We present a linear programming (LP) approach to compute the optimal CE and sample a strategy

profile from one in polynomial time, the method and proofs thereof being applicable to all CA

games. In the case of our offloading system, this method allows any resource allocation scheme

that maintains the class-anonymous property of the game, and we give one particular example

by optimizing over a modified social cost function. We further propose a distributive solution by

leveraging the alternating direction of multipliers method (ADMM), which allows for the effective

utilization of the computing capability of multiple CAPs.

• Simulation results show that our system performance is superior to both a random mapping of the

tasks as well as a regret-based learning method used to compute a non-optimal CE. We also briefly

compare our CE solution method with MCAP under the specific circumstances of the system in

Chapter 2.


1.3 Related Works

While there are many existing works that study the offloading problem in two-tier cloud systems, includ-

ing [19], [20], [21], [22] and [23], among others, fewer works have studied three tier offloading networks.

Such works include [9], [10], [11], [12], [24], [25], [26], and [27]. However, [24], [25], [26], and [27] only

consider the offloading decision and do not attempt to optimize the resource allocation. In both Chapters

2 and 3, we consider the resource allocation problem in conjunction with the offloading decision.

Joint optimization over the offloading decisions and the resource allocation is studied in [9] (and its

extension in [10]) and [11] (and its extension in [12]) where a multi-user, single CAP system with a

remote cloud server was considered. These works present a heuristic centralized solution using a relaxed

SDP for the offloading of one and multiple tasks per round respectively, with delay constraints also

being considered in [10]. As stated above, in Chapters 2 and 3, we consider the more complex problem

of multiple CAPs and add the assumption of selfish users to solve the problem using both SDP and

game theory.

Aside from [13], game-theoretic approaches to analyzing mobile offloading networks have been pre-

sented in [27], [28], [29], [30], [31], [32], [33], [34], and [35]. Similar to our work, all of these works

except [27] and [28] consider a single atomic task per user, while [27], and [28] stand apart for consider-

ing a Poisson generation of user tasks and a queueing system for offloading. All of the remaining works

except that of [29] study systems with potential functions and utilize that fact in the computation of

an NE, although [34] uses the NE as a step to compute the Stackelberg equilibrium. While the system

in [29] is not a potential game, their proof for the existence of an NE relies on the fact that a subgame

within their system is a potential game, and they utilize that fact to modify the finite improvement

method in order to produce an algorithm that could find an NE of the overall game.

In [30] and [31], the finite improvement method from [36] is directly adopted. These works however

do not consider the practical implementation of the finite improvement method, which is expressly con-

sidered in [32] and [33]. In these works, a decentralized solution was presented, where each user computes

their improvements locally, using a pilot signal to determine the the interference at the wireless channel

(which entails all of the necessary information to the user), and a base station that coordinates the trans-

mission of this signal between the users. A similar method is proposed in [34], where the computation

of the improvements are computed by the individual users, with a central controller coordinating these

computations between the users and disclosing the relevant information to them. The finite improvement

method is further improved in [34] by demonstrating theoretical limits to the available strategies for each

user that may result in an improvement. Another decentralized approach is considered in [35], where

each user first adopts a mixed strategy, then uses reinforcement learning to converge to a pure strategy

NE. Thus, [35] does not use the finite improvement method utilized by the other above works to compute

the NE—however, [35] still relies on the existence of an ordinal potential function to demonstrate the

convergence of their solution method to an NE.

By contrast, [13] adopts a centralized approach to computing an NE, which allows the system to

compute an initial starting point to reduce the overall computational time. Furthermore, [37] (which

extended [13]) proved that the system is strategy-proof, thus ensuring that users have no incentive to

provide false information to the controller, which guarantees the viability of a centralized approach.

Because the results in [13] and [37] directly apply to the system in Chapter 2, we assume a similar

centralized approach for our multi-CAP system using the MCAP starting point, and similarly adopt a

centralized approach in computing the optimal CE in Chapter 3. While a centralized approach seems


to be contradictory to the assumption that users have agency over offloading decisions, a centralized

computation of a stable solution would benefit the users by delegating the computation of their offloading

decision to the controller, with a guarantee that the users would not benefit by attempting to search

for a lower-cost deviation. Furthermore, none of the works adopting a decentralized solution method

demonstrate why users have an incentive to participate in that method in the first place—this issue does

not arise under a centralized scheme.

We note again for further emphasis that the potential function is hard to identify in general and may

not exist in practical systems or even any particular subsystem within, thus limiting the applicability

of all of the above approaches. Furthermore, none of their solution methods consider a social objective

function and attempt to produce the socially optimal NE. Our approach in Chapter 3, by using the

CE, does not require the existence of a potential function, and we find the socially optimal CE that

nonetheless maintains the necessary stability conditions in a practical system. This further enforces the

utility of our work in Chapter 3.

Another point of difference regarding these works is the underlying communication model for task

offloading. In [32] and [33], the users offloaded tasks through one or multiple orthogonal wireless channels

respectively, which are shared between them in an interference model. By contrast, [30] considers a single

wireless channel using time-division multiplexing, [31] considers multiple wireless channels via different

access points, with the available bandwidth distributed equally between offloading users, [35] considers

task transmission through carrier sense multiple access (CSMA) over multiple wireless channels, and [29]

and [34] consider multiple shared wireless channels with a generic rate sharing mechanism. Our system

follows the communication model of [31], but does not require equal distribution of bandwidth between

the users. Furthermore, all of these works except [30] assume the users optimize for a weighted sum

of energy and time consumption— [30] exclusively optimizes for energy and adds time requirements

as constraints. In Chapter 4, we allow the users to optimize for any nondecreasing convex function of

energy and time consumption. More importantly, none of these works considers a three-tier computing

systems. In particular, in the offloading systems of [30] and [32] (with a single wireless access point),

or [29], [31], [33], [34], and [35] (with multiple wireless access points), the wireless access points serve only

to forward the offloaded tasks to the cloud. Therefore, their offloading and resource allocation solutions

are not applicable to our problem.

1.4 Thesis Organization

This thesis is organized as follows. Chapter 2 presents the centralized heuristic MCAP and proposes its

use to computing an NE. Chapter 3 presents the CE solution method for the multi-CAP CA offloading

game. Finally, Chapter 4 concludes the thesis.

Chapter 2

Joint Centralized Optimization of

Offloading Decisions and Resource

Allocation

In this chapter, we consider a multi-user mobile edge computing system with multiple computing access

points (CAPs). Each mobile user has multiple dependent tasks that must be processed in a round-by-

round schedule. In every round, a user may process their individual task locally, or choose to offload

their task to one of the M CAPs or the remote cloud server, in order to possibly reduce their processing

cost. We aim to jointly optimize the offloading decisions of the users and the resource allocation decisions

for each CAP over a global objective function, defined as a weighted sum of total energy consumption

and the round time. We present a centralized heuristic solution, termed MCAP, where the original

problem is relaxed to a semi-definite program (SDP) to probabilistically generate the offloading decision.

Recognizing that the users often exhibit selfish behavior to reduce their individual cost, we directly apply

the game-theoretical approach from [13], but use MCAP to provide an initial starting point, termed

MCAP-NE, which we intuit will reduce the computational time in computing an NE. In simulation, we

compare the system cost of the NE solution with those of MCAP, MCAP-NE, a random mapping, and

the optimal solution, showing that our NE solution attains near optimal performance under a wide set

of parameter settings, as well as demonstrating the advantages of using MCAP to produce the initial

point for MCAP-NE.

This chapter is organized as follows. Section 2.1 formulates the problem and system model, culminat-

ing in a centralized optimization problem. Section 2.2 reformulates the system as a QCQP, which is then

optimized heuristically through a relaxed SDP approach which we term MCAP. Section 2.3 explicates

how the MCAP can be used as an initial point in the computation of an NE. Section 2.4 presents our

numerical results. Finally, Section 2.5 concludes the chapter.

2.1 System Model and Centralized Optimization

In this section, we develop the system model in question, denoting all the relevant variables and modeling

the cost of processing at every offloading site. From this, we arrive at a mixed-integer programming

8

Chapter 2. Joint Centralized Optimization of Offloading Decisions and Resource Allocation9

problem to minimize the overall cost of the system.

Consider a cloud access network consisting of one remote cloud server, M CAPs denoted by the set

M ∈ {1, . . . ,M}, and N mobile users denoted by the set N ∈ {1, . . . , N}. Each mobile user may have

multiple tasks to be processed, and we consider a round-by-round schedule where one task from each

user is processed in each round. No task in the next round may begin processing until all the tasks of

the current round have been processed in the system. Because of this condition, it suffices to optimize

the offloading decisions and resources allocation for mobile users in a single round. This will be the focus

of the remainder of the work, and without loss of generality we assume there are N tasks in a round.

2.1.1 Offloading Decision

In each round, a user may process their task locally, or offload it to one of the M CAPs. Each user i

has a possibly empty set of Ki ⊂ M CAPs to which they may not offload their task to. If a task is

offloaded to a CAP, it may be processed there or further offloaded to the remote cloud server. Denote

the offloading decision of user i by

xi = [xi0, xi1, . . . , xiM ] ∈ {0, 1}M+1, (2.1)

θi ∈ {0, 1}, (2.2)

where xi0 = 1 if its task is locally processed locally at the user’s own device, xij = 1, j > 0 if the task

is offloaded to CAP j , and θi = 1 if the task that is offloaded to a CAP is processed at the cloud. We

assume that the tasks are atomic and cannot be placed in multiple locations, only one of xi0, xi1, . . . , xiM

can be active — this can be expressed through the following constraint:

M∑j=0

xij = 1, ∀i ∈ N . (2.3)

Additionally, processing at the cloud can only happen through transmission from one of the CAPs—thus

θi 6= 1 if xi0 = 1. Alternately,

θi ≤M∑j=1

xij , ∀i ∈ N . (2.4)

Finally, the placement constraints of each user are expressed as follows:

xik = 0, ∀k ∈ Ki, i ∈ N . (2.5)

2.1.2 Cost of Local Processing

The input data size, output data size, and required number of processing cycles of user i’s task are

denoted by Din(i), Dout(i), and Y (i), respectively. For local computation, the processing time required

is TLi , and the energy consumption for the user is ELi .

2.1.3 Cost of CAP Processing

For tasks processed at a CAP, the bandwidth and processing rate that is allocated to each user must

be determined in order to compute the energy and time required to complete a task. Each CAP has its


own wireless channel where users may offload their tasks to. The uplink transmission time is given as

T tij =Din(i)

ηuijcuij

, (2.6)

where cuij is the uplink bandwidth to CAP j assigned to user i, and ηuij is the spectral efficiency of the

uplink transmission from user i to CAP j.1 The downlink transmission time is given as

T rij =Dout(i)

ηdijcdij

, (2.7)

where cdij and ηdij is the respective downlink bandwidth and spectral efficiency. The bandwidths cuij and

cdij are further limited by bandwidth capacities as follows:

N∑i=1

cuij ≤ CULj , ∀j ∈M, (2.8)

N∑i=1

cdij ≤ CDLj , ∀j ∈M, (2.9)

N∑i=1

(cuij + cdij) ≤ CTotalj , ∀j ∈M. (2.10)

Furthermore, a task is processed at the CAP with processing time T aij = Y (i)/faij , where faij is the

processing rate at CAP j assigned to user i, and constrained by the total processing rate of the CAP:

N∑i=1

faij ≤ fAj , ∀j ∈M. (2.11)

The total time required for processing task i on CAP j can then be expressed as

TAij = T tij + T rij + T aij . (2.12)

The energy consumption required for CAP processing can be expressed as

EAij = Etij + Erij , (2.13)

where Etij and Erij represent the uplink and downlink transmission energy costs required by the user,

respectively.

2.1.4 Cost of Cloud Processing

For cloud processing, the uplink and downlink transmission energies and times are identical to the CAP

processing case. However, there is now further transmission time between the CAP and the cloud,

expressed as T aci = (Din(i)+Dout(i))/rac, where rac is a predetermined wired transmission rate between

the CAPs and the cloud. The computation time is T ci = Y (i)/fCi , where fCi is a predetermined processing

1The spectral efficiency can be approximated by the Shannon bound log(1 + SNR), where SNR is the signal-to-noiseratio between the user and the CAP.


Table 2.1: Parameters and Respective Descriptions.

Parameter DescriptionELi local processing energy of user i’s task

Etij , Erij uplink transmitting energy and downlink

receiving energy of user i’s task to andfrom CAP j, respectively

TLi , TCi local processing time and cloud processing timeof user i’s task, respectively

T tij , Ttij uplink transmission time and downlink

transmission time of user i’s task betweena mobile user and CAP j, respectively

T aci transmission time of user i’s task between CAPand cloud

CULj , CDL

j , CTotalj uplink, downlink, and total transmission capacity

associated with CAP j, respectivelycuij , c

dij uplink and downlink bandwidth

assigned to user i from CAP jfaij CAP processing rate assigned to user i from

CAP jηuij , η

dij uplink and downlink spectral efficiency

from user i to CAP jCCi system utility cost of user i’s taskrac transmission rate for each user

between the CAP and cloudfCi cloud processing rate for each user

rate assigned to each user at the cloud. Thus, the total cloud processing time can be expressed as

TCij = T tij + T rij + T aci + T ci . (2.14)

The energy consumption can be expressed as

ECij = Etij + Erij + βiCCi , (2.15)

where CCiis the cloud utility cost, and βi is the relative weight.

These various parameters are summarized in Table 2.1.

2.1.5 Optimization Problem Formulation

To maintain adequate quality of service for each user, we seek to minimize both the energy consumption

and the processing time. Because of the round-by-round schedule, each user experiences the same

processing delay between tasks, which is the total round time. Thus, our centralized optimization

problem considers a weighted sum of the total energy consumption among the users and the round time,

which is the maximum processing time among all of the tasks in the round. Our decision variables are

the offloading decisions xi and θi, as well as the resource allocation decisions cui = [cui1, . . . , cuiM ], cdi =

[cdi1, . . . , cdiM ], and fai = [fai1, . . . , f

aiM ]. Thus, the optimization problem is as follows:


min{xi},{θi}{cu

i },{cdi },{fai }

{N∑i=1

αi(ELi+ EAi

+ ECi) + max

i′∈N{TLi′ + TAi′ + TCi′}

}, (2.16)

s.t. (2.1)-(2.5), (2.8)-(2.11),

cuij , cdij , f

aij ≥ 0, ∀i ∈ N , j ∈M, (2.17)

where

ELi= ELi xi0, TLi

= T lixi0,

EAi =

M∑j=1

EAijxij(1− θi), TAi =

M∑j=1

TAij xij(1− θi),

ECi =

M∑j=1

ECijxijθi, TCi =

M∑j=1

TCij xijθi,

i ∈ N ,

where αi is a relative weight between the energy consumption and the round time.

2.2 MCAP Offloading Solution

The resultant centralized optimization problem is a non-convex mixed integer programming problem,

and no known method exists for efficiently finding a global optimum. We therefore propose the MCAP

method for finding a heuristic solution. In this method, we transform the original problem into a

quadratically-constrained quadratic programming (QCQP) problem, then relax the integer constraints

on the offloading variables in order to produce an SDP over real-valued offloading decisions variables,

as explicated in [16]. This overall QCQP-SDP solution framework is generic and was used also in [9]

and [11] for the case of a single CAP. However, because of the presence of multiple CAPs, there are new

challenges in applying these methods to the current system, due to the substantial addition of objective

variables and constraints that result. In particular, we must accommodate for the additional offloading

variable θ and associated constraints (2.2) and (2.4), the additional dimensionality of offloading variables

xi and resource allocation variables cuij , cdij , and faij , as well as their associated constraints (2.8)-(2.11),

and the addition of placement constraints (2.5).

Through the solution of the SDP, a probabilistic mapping method is used to recover a set of binary-

valued offloading decisions. Once a set of offloading decisions have been recovered, we compute the

optimal resource allocation problem for each one, which can be expressed as the following optimization

problem:

min{cu

i },{cdi },{fai }

{N∑i=1

αi(ELi+ EAi

+ ECi) + max

i′∈N{TLi′ + TAi′ + TCi′}

}, (2.18)

s.t. (2.8)-(2.11), (2.17),

which is a convex problem, since it is a maximum of sums of positive reciprocal functions with linear


constraints, and thus can be solved using any standard convex solver. From these solutions, we choose

the one that minimizes the system objective (2.16).

2.2.1 QCQP Formulation

In order to reformulate (2.16) as a QCQP, we first replace the integer constraints (2.1) and (2.2) with

the following quadratic constraints:

xij(xij − 1) = 0, ∀i ∈ N , j ∈ {0} ∪M (2.19)

θi(θi − 1) = 0, ∀i ∈ N . (2.20)

We then introduce an auxiliary variable t in order to remove the maximum in the objective and

re-express that condition as a constraint. The objective now becomes

min{xi},{cu

i },{cdi },{fai },t

{N∑i=1

αi(ELi+ EAi

,+ECi) + t

}, (2.21)

with a new delay constraint:

TLi xi0 +

M∑j=1

(Din(i)

ηuijcuij

+Dout(i)

ηdijcdij

+Y (i)

faij(1− θi)

)xij +

(T aci + T ci

)θi ≤ t, ∀i ∈ N . (2.22)

We now introduce a set of auxiliary variables Duij , D

dij , and Da

ij for each set of users and CAPs, and

replace the above delay constraint with the following:

Din(i)

ηuijcuij

xij ≤ Duij , ∀i ∈ N , j ∈M, (2.23)

Dout(i)

ηdijcdij

xij ≤ Ddij , ∀i ∈ N , j ∈M, (2.24)

Y (i)

faijxij(1− θi) ≤ Da

ij , ∀i ∈ N , j ∈M, (2.25)

TLi xi0 +

M∑j=1

(Duij +Dd

ij +Daij) + (T aci + TCi )θi ≤ t, ∀i ∈ N . (2.26)

With Dui = [Du

i0, . . . , DuiM ], Dd

i = [Ddi0, . . . , D

diM ] and Da

i = [Dai0, . . . , D

aiM ] we can then vectorize all of

the variables and parameters into one vector w, defined as

w = [x1, . . . ,xN , θ1, . . . , θN , cu1 , . . . , c

uN ,D

u1 , . . . ,D

uN , c

d1, . . . , c

dN ,D

d1, . . . ,D

dN fa1 , . . . , f

aN ,D

a1 , . . . ,D

aN , t]

T

(2.27)

By doing so, we can rewrite our objective function as

bT0 w, (2.28)


where

b0 = [α1El1, α1E

A1,1, . . . , α1E

A1,M , . . . , αNE

AN,M , α1β1CC1

, . . . , α1β1CC1,01×6MN , 1]T .

Similarly, each of the constraints above can be rewritten in matrix form. The time constraint (2.26)

can be expressed as

(bci )Tw ≤ 0, ∀i ∈ N , (2.29)

where

bci = [01×(M+1)(i−1)+1, TLi ,

01×(M+1)(N−i+M−1),01×(i−1), Taci + TCi ,

01×(N−i)01×(MN+(i−1)N),11×N ,01×(N−i)M ,

01×(N−i)01×(MN+(i−1)N),11×N ,01×(N−i)M ,

01×(N−i)01×(MN+(i−1)N),11×N ,01×(N−i)M ,−1]T .

To express constraints (2.23)-(2.25), we rearrange their respective expressions to produce the following

equivalent inequalities:

Din(i)xij − ηuijcuijDuij ≤ 0,

Dout(i)xij − ηuijcuijDdij ≤ 0,

Y (i)xij − Y (i)xijθi − faijDaij ≤ 0.

Equations (2.23)-(2.25) can now be expressed as

wTAµijw + (bµi )Tw ≤ 0, µ ∈ {u, d, a}, ∀i ∈ N , j ∈M, (2.30)

where ei is a unit vector of size MN of dimension i, and

Au′

ij = −0.5ηuij

[0MN×MN diag(ei)

diag(ei) 0MN×MN

],

Ad′

ij = −0.5ηdij

[0MN×MN diag(ei)

diag(ei) 0MN×MN

],

Aa′1ij = −0.5

[0MN×MN diag(ei)

diag(ei) 0MN×MN

],

Aa′2ij ∈ R(M+1)N×(M+1)N such that

{Aa′2ij

}α,β

=

−0.5Y (i), α = (M + 1)N + j, β = (M + 1)(i− 1) + j

−0.5Y (i), α = (M + 1)(i− 1) + j, β = (M + 1)N + j

0, otherwise

,


Auij =

0(M+2)N×(M+2)N 0(M+2)N×2MN 0(M+2)N×4MN+1

02MN×(M+2)N Au′

ij 02MN×4MN+1,

04MN+1×(M+2)N 04MN+1×2MN 04MN+1×4MN+1

,

Adij =

0(3M+2)N×(3M+2)N 0(3M+2)N×2MN 0(3M+2)N×2MN+1

02MN×(3M+2)N Ad′

ij 02MN×2MN+1

02MN+1×(3M+2)N 02MN+1×2MN 02MN+1×2MN+1

,

Aa1ij =

0(5M+2)N×(5M+2)N 0(5M+2)N×2MN 0(5M+2)N×1

02MN×(5M+2)N Aa′1ij 02MN×1

01×(5M+2)N 01×2MN 0

,Aa2ij =

[Aa′2ij 0(M+2)N×6MN+1

06MN+1×(M+2)N 06MN+1×6MN+1

],

Aaij = Aa1

ij + Aa2ij ,

buij = [01×(M+1)(i−1)+j−1, Din(i),01×(7N−i+1)M+2N−i−j ]T ,

bdij = [01×(M+1)(i−1)+j−1, Dout(i),01×(7N−i+1)M+2N−i−j ]T ,

baij = [01×1×(M+1)(i−1)+j−1, Y (i),01×(7N−i+1)M+2N−i−j ]T .

The offloading constraints (2.3) and (2.4) become

bPi w = 1, ∀i ∈ N , (2.31)

bQi w ≤ 0, ∀i ∈ N , (2.32)

where

bPi = [01×(i−1)(M+1),11×M+1,01×7MN+2N−iM−i+1]T ,

bQi = [01×(i−1)(M+1)+1 − 11×M ,01×(N−i)(M+1)+i−1, 1,06MN+1−N+i]T .

The bandwidth and processing capacities constraints (2.8)-(2.11) become

bUj w ≤ CULj , ∀j ∈M, (2.33)

bDj w ≤ CDLj , ∀j ∈M, (2.34)

bSj w ≤ CTotalj , ∀j ∈M, (2.35)

bAj w ≤ fAj , ∀j ∈M, (2.36)

where

b′j = [01×j−1, 1,01×M−j ],

bUj = [01×(M+2)N , {b′j}1×N ,01×5MN+1],

bDj = [01×(3M+2)N , {b′j}1×N ,01×3MN+1],

bSj = bUj + bDj ,

bAj = [01×(5M+2)N , {b′j}1×N ,01×MN+1].


The nonnegative constraint (2.17) becomes

w � 0, (2.37)

while the integer constraints (2.19)-(2.20) can be written as

wTepw − eTp w = 0, ∀p ∈ {1, . . . , (M + 2)N}, (2.38)

where ep is a unit vector of size 7MN + 2N + 1 of dimension p.

Finally, the placement constraints (2.5) can be expressed as2

bKi w = 0, ∀i ∈ N , (2.39)

where

bKi =∑k∈Ki

e(M+2)(i−1)+k.

Hence, the QCQP formulation of (2.16) can be expressed equivalently as

minw

b0w, (2.40)

s.t. (2.29)-(2.39).

2.2.2 SDP Solution

In order to arrive at the SDP formulation from (2.40), we must express the problem in matrix form. We

begin by defining the vector z = [w 1]T , and reformulate (2.40) in terms of z. We denote 0 as the zero

matrix of dimension 7MN + 2N + 1 × 7MN + 2N + 1, and ep is a unit vector of size 7MN + 2N + 1

and dimension p.

The objective function from (2.28) now becomes

minz

zTG0z, (2.41)

where

G0 =

[0 1

2b0

12bT0 0

].

Constraint (2.29) is now expressed as

zTGciz ≤ 0, ∀i ∈ N , (2.42)

2Strictly speaking, there should be one equality constraint for each individual placement constraint of each user. How-ever, because we have a nonnegative constraint (2.37), the sum constraint provided above is sufficient.


where

Gci =

[0 1

2bci12 (bci )

T 0

];

(2.30) is expressed as

zTGµijz ≤ 0, ∀µ ∈ {u, d, a}, i ∈ N , j ∈M (2.43)

where

Gµij =

[Aµij

12bµij

12 (bµij)

T 0

], µ ∈ {u, d, a};

(2.31) and (2.32) are expressed as

zTGPi z = 1, ∀i ∈ N , (2.44)

zTGQi z ≤ 0, ∀i ∈ N , (2.45)

where

GPi =

[0 1

2bPi12 (bPi )T 0

],

GQi =

[0 1

2bQi12 (bQi )T 0

];

(2.33)-(2.36) are expressed as

zTGUj z ≤ CUL

j , ∀j ∈M, (2.46)

zTGDj z ≤ CDL

j , ∀j ∈M, (2.47)

zTGSj z ≤ CTotal

j , ∀j ∈M, (2.48)

zTGAj z ≤ fAj , ∀j ∈M, (2.49)

where

Gπj =

[0 1

2bπj12 (bπj )T 0

], π ∈ {U,D, S,A};


z � 0; (2.50)


zTGIpz = 0, ∀p ∈ {1, . . . , (M + 2)N}, (2.51)


where

GIp =

[diag(ep) − 1

2ep

− 12 (ep)

T 0

];

and finally, (2.39) is expressed as

zTGKi z = 0, ∀i ∈ N , (2.52)

where

GKi =

[0 1

2bKi12 (bKi )T 0

].

Problem (2.40) can now be equivalently transformed to:

minz

zTG0z, (2.53)

s.t. (2.42)-(2.52).

Define Z = zzT . We can reformulate (2.53) as an SDP under Z, subject to an additional rank

constraint: rank(Z) = 1. Note that because z � 0, Z must be both positive semidefinite and element-

wise nonnegative in order for the above problems to be equivalent. By dropping the rank constraint, we

have the following convex problem:

minZ

Tr(G0Z), (2.54)

s.t. Tr(GciZ) ≤ 0, ∀i ∈ N , (2.55)

Tr(GµijZ) ≤ 0, ∀µ ∈ {u, d, a}, i ∈ N , j ∈M, (2.56)

Tr(GPi Z) = 1, ∀i ∈ N , (2.57)

Tr(GQi Z) ≤ 0, ∀i ∈ N , (2.58)

Tr(GUj Z) ≤ CUL

j , ∀j ∈M, (2.59)

Tr(GDj Z) ≤ CDL

j , ∀j ∈M, (2.60)

Tr(GSj Z) ≤ CTotal

j , ∀j ∈M, (2.61)

Tr(GAj Z) ≤ fAj , ∀j ∈M, (2.62)

Tr(GIpZ) = 0, ∀p ∈ {1, . . . , (M + 2)N}, (2.63)

Tr(GKi Z) = 0, ∀i ∈ N , (2.64)

Z � 0 (elementwise), (2.65)

Z ∈ S+7MN+2N+2. (2.66)

This is a standard form SDP problem, and thus can be solved in polynomial time using an SDP

solver. Denote the resultant solution as Z∗. From this, we must recover a set of binary offloading

decisions as a heuristic solution to the original problem (2.16). There are multiple means of recovering

a rank-1 solution from a relaxed SDP, as detailed in [16]. One such method involves generating a set of


vectors from a zero-mean, Z∗ covariance Gaussian distribution and mapping each element to the set of

possible decisions {0, 1}. Such a method however would not guarantee that that constraints (2.3) and

(2.4) would be satisfied. Given the parameters of our particular problem, we instead use a randomization

method to recover our solution, adopted in [9].

Note that the elements Z(7MN +2N +2, 1) to Z(7MN +2N +2, (M +1)N) correspond to the CAP

decision vectors x1 to xN , while Z(7MN + 2N + 2, (M + 1)N + 1) to Z(7MN + 2N + 2, (M + 2)N)

correspond to the cloud decision variables θ1 to θN . This arises from the fact that Z = zzT and z = [w1],

and therefore the last row of Z correspond to the elements in w, the first (M + 2)N of which are equal

to [x1, . . . ,xN , θ1, . . . , θN ]. In order to use these results in our randomization method, we must prove

the following lemma. Even though its is similar in form to Lemma 1 in [9], for the case of multiple CAPs

we must reformulate the lemma for the dimensions of our Z matrix, as well as account for the additional

offloading decision variable θ and associated constraint (2.4).

Lemma 1. For the optimal solution Z∗ of (2.54), Z∗(7MN+2N+2, p) ∈ [0, 1],∀p ∈ {1, . . . , (M+2)N}

Proof. From (2.65), we are guaranteed that all elements of Z∗ are nonnegative. For p ∈ {1, . . . , (M +

1)N}, constraint (2.57) requires that

(M+1)i∑p=(M+1)(i−1)+1

Z∗(7MN + 2N + 2, p) = 1, ∀i ∈ {1, . . . , N},

which ensures that each of the above elements individually are less than or equal to 1. For p ∈ {(M +

1)N + 1, . . . , (M + 2)N}, (2.58) requires that

Z∗(7MN + 2N + 2, (M + 1)N + i) ≤(M+1)i∑

p=(M+1)(i−1)+2

Z∗(7MN + 2N + 2, p), ∀i ∈ {1, . . . , N}.

This ensures that the above sum must be less than or equal to 1, which ensures that Z∗(7MN + 2N +

2, p) ≤ 1 for that range of p.

Using Lemma 1, we interpret each element of Z(7MN + 2N + 2, p), p ∈ {1, . . . , (M + 2)N} as the

marginal probability of offloading. Furthermore, we note that the combination of (2.64) and (2.65)

guarantees that all placement constraints in the recovered probabilities are also met—thus the assigned

probability of a user offloading to a forbidden CAP is 0. We can recover these probabilities for each user

and denote them through the following vectors:

pxi = [pi0 . . . piM ], ∀i ∈ N ,

= [Z(7MN + 2N + 2, (M + 1)(i− 1) + 1), . . . ,Z(7MN + 2N + 2, (M + 1)i)],

Pxi = [Pi0 . . . PiM ],

s.t. Pij =pij∑Mk=0 pik

, j ∈ {0} ∪M,

P θi =Z(7MN + 2N + 2, (M + 1)N + i)

1− Pi0,

where pxi is the original vector of recovered probabilities, Pxi is the normalized pxi (done in case of any

numerical imprecisions such that the total sum may not exactly equal 1), and P θi is the conditional


Algorithm 1 MCAP Offloading Algorithm

1: Solve SDP problem (2.54) to obtain matrix Z∗.2: Recover Z∗, and compute Px

i and P θi3: for m = 1 to M do4: Generate x

(m)i and θ

(m)i from Px

i and P θi5: Solve (2.18) and record the system cost J (m) and resource allocation decisions cu

(m)

i , cd(m)

i , and

fa(m)

i

6: end for7: Find trial that produces the lowest cost: m∗ = arg min J (m)

8: Output: {x∗i } = {x(m∗)i }, {θ∗i } = {θ(m∗)

i } {cu∗i } = {cu(m∗)

i }, {cd(m∗)i } = {cd∗i }, and {fa∗i } = {fa(m∗)i }

probability of cloud offloading given that there is transmission to a CAP. The adjustment to P θi is due

to the fact that offloading to the cloud is impossible when local processing occurs.

The probabilistic mapping Pxi is then used to produce the random vector ui ∈ {0, 1}M+1, which

denotes a offloading decision:

ui = ej with probability Pij , ∀j ∈ {0} ∪M, (2.67)

Θi =

0, with probability 1 if Pi0 = 1, 1− P θi otherwise

1, with probability 0 if Pi0 = 1, P θi otherwise, (2.68)

where ej is the unit vector of size M + 1 with dimension j.

Using this probability distribution, we generate K i.i.d. trial solutions x(m)i and θ

(m)i from the random

vectors ui and Θi. We solve problem (2.18) in each one to obtain a set of offloading decisions the optimal

set of offloading decisions from the trials. From this, we obtain a set of offloading decisions {x∗i } and

{θ∗i } with a corresponding set of resource allocation decisions {cu∗i }, {cd∗

i }, and {fa∗i }, from which we

select the one that gives the minimal objective (2.18).

The process stated above is outlined in Algorithm 1. From observation, we have found that about

K = 10 random trials are sufficient to produce near optimal system performance.

2.3 Selfish User Assumption

The optimization problem (2.16) does not necessarily produce stable conditions if the users are selfish

have agency over their offloading decisions. To account for this possibility, we directly apply game-

theoretic methods from [13] to derive an NE solution method, improving upon it by using MCAP as the

initial point, thereby reducing the computational time required to compute an NE.

2.3.1 Game Formulation and Properties

We consider the system model with selfish users as a strategic form game:

G = (N , (Ai)i∈N , (ui)i∈N ), (2.69)

where N = {1, ..., N} is the player set containing all mobile users, Ai = {ai} is the strategy set for user

i, and ui is the corresponding cost function that user i aims to minimize. Here, {ai} = {(xi, θi)} and ui

is a function of the strategy profile a = (ai, a−i), where ai ∈ Ai, and a−i = (a1, ..., ai−1, ..., ai+1, ..., aN ) ∈


A−i =∏j 6=iAj . By choosing their offloading site ai, user i can decide where to process their task to

minimize their cost function ui. Thus, the users may decide against choosing the offloading decision

dictated by some centralized solution to the problem above. To account for this, we seek a solution

method that produces an NE, where no user has any incentive to deviate from their dictated solution

given the decisions of the other users.

We assume a very specific form of the individual objective, a weighted sum of a user’s individual

energy consumption and round time:

ui(a1, . . . , aN ) = αi(ELi + EAi + ECi) + maxi′∈N{TLi′ + TAi′ + TCi′}, (2.70)

where αi is the relative weight for user i.

Given this particular assumption, the following proposition is a direct result of the proof in [13] for

the single-CAP case:

Definition 1. A strategic form game G is an ordinal potential game (OPG) if there exists an ordinal

potential function φ :∏iAi → R such that

sgn(ui(ai, a−i)− ui(a′i, a−i)) = sgn(φ(ai, a−i)− φ(a′i, a−i)), ∀i ∈ N , (2.71)

where ai, a′i ∈ Ai, a−i ∈ A−i.

Proposition 1. The mobile cloud offloading game G is an OPG.

Because our offloading game is an OPG, we can compute a PSNE of the system via the finite

improvement method [36]. The finite improvement method is as follows. From an initial series of

offloading decisions, each user one-by-one iterates over all the possible offloading decisions, until they

find a decision that reduces their individual objective above. This is repeated until no users can improve

upon their offloading decisions, at which point a Nash equilibrium is reached. This method is guaranteed

to terminate in an OPG from the results in [36].

2.3.2 MCAP-NE Offloading Algorithm

To implement the finite improvement method in our system, we propose the centralized approach adopted

in [13] to compute an NE. Under that approach, users provide their task information and weights αi

to the CAP, which acts as a central controller. The controller computes an NE of the system using

the finite improvement method, then sends the resultant offloading decisions to each user. Because

the resultant solution is an NE, users have no incentive to deviate from their given offloading decision.

Furthermore, [37] shows that under such a centralized approach no users has any incentive to provide

false information to the central controller (the proof also being directly applicable to the multi-CAP

system), thus ensuring the viability of the centralized approach.

While any initial starting point will eventually lead to an NE through the finite improvement method,

the choice of initial point may have an effect on the length of the improvement path. Since each step

of the improvement path method may require a nontrivial amount of time (due to the combinatorial

nature of the finite improvement method), reducing the number of iterations of this method can greatly

improve the computational time required to compute an NE. Thus, we propose using the result of the

MCAP method as our initial point. Because the result from the MCAP algorithm is substantially closer


Algorithm 2 MCAP-NE Offloading Algorithm

1: Obtain an initial strategy profile a[0] and corresponding resource allocation decisions {cui }, {cdi }, and{fai } from Algorithm 1.

2: Set NE = False and k = 0.3: while NE == False do flag = 0 and i = 1;4: while flag == 0 and i ≤ N do5: Calculate {cu∗i }, {cd

∗

i }, and {fa∗i } for (a′i, a−i[k]), for all a′i ∈ Ai;6: if ui(a[k]) > ui(a

′i, a−i[k]), a′i ∈ Ai then

7: Set ai[k + 1] = a′i, a−i[k + 1] = a−i[k];8: Set a[k + 1] = (ai[k + 1], a−i[k + 1]), flag = 1;9: k = k + 1;

10: else if i == N then11: Set flag = 1, NE = True;12: else13: i = i+ 1;14: end if15: end while16: end while17: Output: the NE a∗ of G and the corresponding resource allocation {cu∗i }, {cd

∗

i }, and {fa∗i }.

to optimal than a random starting point, we expect that using the MCAP solution as our initial point

will reduce the number of iterations required to compute an NE, which we have confirmed in simulation.

The details of the proposed algorithm, which we term MCAP-NE, are given in Algorithm 2.

2.4 Simulation Results

In this section, we detail the simulation results of MCAP and MCAP-NE. We first consider a system

without any user placement constraints, subjecting the system through a series of parameter changes. We

observe the system cost and the number of iterations required using the different optimization methods.

We then consider the addition of placement constraints in the system.

2.4.1 Default Parameters

We utilize the x264 CBR encoding application, which requires 1900 cycles/byte [38]. x264 is commonly

used in encoding for video streams and thus can be applied to potential MEC applications such as

virtual reality or online gaming. The input and output data sizes of each task are assumed to be

uniformly distributed from 10MB to 30MB and from 1MB to 3MB, respectively. We set by default

the number of users N = 10, number of CAPs M = 2, α = 0.5 s/J, and β = 1.7 × 10−7 J/bit. The

bandwidths at each CAP are CjUL = CjDL = 20 MHz, and CjTotal = 40MHz for each CAP, and the

spectral efficiencies ηuij = ηdij are uniformly distributed between 2 and 5 b/s/Hz, which correspond to

typical WiFi communication settings. We use an iPhone X mobile device with a CPU speed of 2.39×109

cycles/s, leading to a local computation time of 9.93× 10−8 s/bit [39], and adopt a CPU rate of 5× 109

cycles/s at the CAPs, and 7.5 × 109 cycles/s at the cloud. The transmission and receiving energy per

bit at each mobile device are both 1.42×10−7 J/bit as indicated in Table 2 in [38]. For offloading a task

to the cloud, the transmission rate is Rac = 15 Mpbs. Also, we set the cloud utility cost Cci to be the

same as that of the input data size Din(i). These parameter values are listed in Table 2.2.


Table 2.2: Default Simulation Parameter Values

Parameter Default ValueProcessing cycles per byte 1900Minimum input data size 10 MBMaximum input data size 30 MB

Minimum output data size 1 MBMaximum output data size 3 MB

Number of CAPs 2αi 0.5 s/J, ∀iβi 1.7 ×10−7

CjUL, CjDL 20 MHz, ∀j

CjTotal 40 MHz, ∀jMinimum ηuij , η

dij 2 b/s/Hz, ∀i, j

Maximum ηuij , ηdij 5 b/s/Hz, ∀i, j

Local CPU speed 2.39× 109 cycles/sCAP CPU speed 5× 109 cycles/s

Cloud CPU speed 7.5× 109 cycles/sTx and Rx energy 1.42× 10−7 cycles/s

CAP to cloud transmission rate Rac = 15 Mpbs

2.4.2 Impact of Different Parameters

We run the simulation through 50 rounds, with the input and output data size of each task being

independently and identically generated, and plot the averaged total system cost. We compare the per-

formance of MCAP and MCAP-NE against the optimal solution (obtained through exhaustive search),

a random mapping of offloading decisions, and the NE results with random mapping as the starting

point.

We consider the above system settings while varying a single parameter, in order to demonstrate our

solution’s superior performance under a variety of settings. We note that in each of these figures, both

MCAP and MCAP-NE incur costs close to that of the optimal solution, despite the great strategy space

available, while MCAP-NE consistently improves slightly upon MCAP. This shows that our solution is

highly reliable in recovering near-optimal solutions to the multi-CAP optimization problem. By contrast,

random mapping consistently performs far worse. Figure 2.1a shows that the cost decreases with the

number of available CAPs, which is expected given the additional resources that each CAP provides

to the users. Figure 3.1, shows that the system cost increases with the number of users, which is as

expected given the added competition of resources these users produce. Figures 2.3a and 2.4a both show

that the system cost increases with an increase in the cost weights α and β, though the increase levels

off with β. This is because increasing β would have no effect when it is already too high for the users to

utilize cloud processing.

Figures 2.1b, 2.2b, 2.3b, and 2.4b show the number of iterations required to compute an NE against

the number of CAPs, the number of users, α, and β, respectively, with either a random starting point or

an MCAP starting point. In all of these figures, we see that number of iterations required to obtain an

NE is more than doubled when using a random starting point as opposed to the MCAP-NE, confirming

the performance benefit of using MCAP for an initial starting point. While the addition of CAPs does

not noticeably increase the number of iterations required, the number of users does have a discernible

effect due to the additional number of possible users who may find an improvement. As expected, α and

β have no discernible effect as those parameters do not affect the size of the strategy space.


1 2 3 4

Number of CAPs

100

150

200

250

300

350

400

Co

st

(s)

Random Mapping NE

Random Mapping

MCAP

MCAP-NE

Optimal Solution

(a) Cost against number of CAPs

1 2 3 4

Number of CAPs

3

4

5

6

7

8

Num

ber

of Itera

tions

Random Mapping NE

MCAP-NE

(b) Number of iterations required against number of CAPs

Figure 2.1: Impact of the number of CAPs


8 10 12

Number of Users

150

200

250

300

350

400

Co

st

(s)

Random Mapping NE

Random Mapping

MCAP

MCAP-NE

Optimal Solution

(a) Cost against number of users

8 10 12

Number of Users

3

4

5

6

7

8

9

Nu

mb

er

of

Ite

ratio

ns Random Mapping NE

MCAP-NE

(b) Number of Iterations against the number of users

Figure 2.2: Impact of number of users


0.1 0.3 0.5 0.7 0.9

(s/J)

100

150

200

250

300

350

400

450

Cost (s

)

Random Mapping NE

Random Mapping

MCAP

MCAP-NE

Optimal Solution

(a) Cost against α

0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9

(s/J)

3

4

5

6

7

8

Num

ber

of Itera

tions

Random Mapping NE

MCAP NE

(b) Number of iterations against α

Figure 2.3: Impact of α


1 2 3 4 5

(J/bit) 10-7

150

200

250

300

350

400

450

Co

st

(s)

Random Mapping NE

Random Mapping

MCAP

MCAP-NE

Optimal Solution

(a) Cost against β

1 2 3 4 5

(J/bit) 10-7

3

4

5

6

7

8

Num

ber

of Itera

tions

Random Mapping NE

MCAP-NE

(b) Number of iterations required β

Figure 2.4: Impact of β


8 12 16

Number of Users

200

250

300

350

400

450

Co

st

(s)

Random Mapping NE

Random Mapping

MCAP

MCAP-NE

Figure 2.5: Cost against the number of users with placement constraints

Random Mapping NE Random Mapping MCAP MCAP-NE0

50

100

150

200

250

300

350

400

Cost (s

)

With Placement Constraints

Without Placement Constraints

Figure 2.6: Cost with placement constraints and without placement constraints

2.4.3 Placement Constraints

We now study a system in the presence of placement constraints. Here, we consider a system of 12 users

by default, randomly assigning as a placement constraint either one of the CAPs or the empty set with

equal probability. All of the other parameters of the system are the same as in Section VI-A.

Figures 2.5 shows the system cost against the number of users under the system with placement

constraints. We note that the behaviour here is similar to the behaviour in the system without placement

constraints — the cost is increasing with respect to the number of users, and relative performance between


offloading methods remain close to the original case. Figure 2.6 compares a system with placement

constraints with a system without placement constraints. We observe that the system with placement

constraints requires a higher cost, as beneficial offloading decisions that would otherwise be desirable

cannot be made.

2.5 Summary

In this chapter, a multi-user mobile cloud computing system with multiple CAPs has been considered,

in which each mobile user has a task to be processed either locally, at one of the CAPs, subject to

the user’s placement constraint, or at a remote cloud. We solve the non-convex optimization problem

through two approaches: in MCAP we formulate the problem as a QCQP and use an SDP relaxation to

arrive at a heuristic solution; while in MCAP-NE, we accommodate selfish users by leveraging the finite

improvement property of an ordinal potential game to find an NE. Simulation results show near optimal

performance of our methods as well as the utility of the SDP starting point in substantially reducing

the number of iterations required to compute an NE.

Chapter 3

Socially Optimal Correlated

Equilibrium of Offloading Decisions

In this chapter, we consider a multi-user mobile offloading network with multiple computing access points

(CAPs). Each user has one task to be processed, and may choose to reduce the cost of processing the task

by offloading it to a CAP or to a remote cloud server, subject to their placement constraints. Each user

belongs to one of a fixed number of classes, which determines the distribution of their task parameters

and their mobile device characteristics. We aim to produce an offloading decision that minimizes the

expected social cost of the system, defined as a weighted sum of the individual user costs, while giving

rational and selfish users incentive to follow that decision. Towards this goal, we compute the socially

optimal correlated equilibrium (CE), which is a distribution over the strategy space of the system such

that no user has any incentive to deviate from a strategy drawn from that distribution. We show that

our system can be formulated as a class-anonymous (CA) game, and we derive the reduced form of this

game to prove that the optimal CE can be computed in polynomial time and space with respect to the

number of users. Like the Nash Equilibrium, the CE maintains the necessary conditions for stability

in a system with rational and selfish users, while being much easier to compute for non-potential finite

games.

While the computation of a non-optimal CE can be distributed through the set of players in a

game via a regret-based learning approach [45], these methods do not apply to the computation of a

socially optimal CE. To produce an optimal CE solution, we propose a centralized linear program (LP)

whose computation is distributed through the multiple CAPs in the system via ADMM. We use the

solution of the LP to produce a series of bipartite graphs, and then develop a polynomial time sampling

algorithm that randomly generates a strategy profile from these graphs through Birkhoff’s theorem. Our

theoretical results then show that the implicit distribution that results from this sampling algorithm (i.e.

the empirical distribution from a very large number of samples) is a CE with optimal expected social

cost. Simulation results demonstrate the superior results of our solution when compared with random

mapping and an alternate means of computing a CE. We also briefly compare our CE solution method

with MCAP under the specific system model presented in Chapter 2.

The chapter is organized as follows. Section 3.1 formulates the system model. Section 3.2 defines

the offloading game, shows that it is an example of a CA game, discusses the CE, and provides a proof

that a socially optimal CE can be found for CA games in polynomial time. Section 3.3 uses those

30

Chapter 3. Socially Optimal Correlated Equilibrium of Offloading Decisions 31

results to develop our solution method. Section 3.4 presents our simulation results. Finally, Section 3.5

summarizes the chapter.

3.1 System Model

In this section, we develop the system model in question, denoting all the relevant variables and modeling

the cost of processing at every offloading site. We note that there are subtle differences in notation

between the following and the system model in 2.1—thus we present the model here again in its entirety.

Consider a cloud access network consisting of one remote cloud server, M CAPs denoted by the set

M ∈ {1, . . . ,M}, and N mobile users denoted by the set N ∈ {1, . . . , N}. Each user has a single task

to be processed at time zero. This model can be extended to the scenario where the users have multiple

tasks, if the tasks are processed in a round-robin manner among the users.

3.1.1 Offloading Decision

Each user may process their task locally, or offload it to one of the M CAPs. The tasks offloaded to

the CAP may be processed there or may be further offloaded to the remote cloud server. Denote the

offloading decision for each user as the binary vector

xi = [xi0, xi1, . . . , xiM , xi(M+1), . . . , xi(2M)]T , (3.1)

where xij = 1 for j = 0 if user i’s task is to be processed locally, xij = 1 for 1 ≤ j ≤ M if the task is

to be offloaded and processed at CAP j, and xij = 1 for j > M if the task is to be offloaded at CAP

j −M and processed at the cloud. The tasks are atomic and thus cannot be split between sites:

2M∑j=0

xij = 1, ∀i ∈ N . (3.2)

Each user may also have a possibly empty set Li ⊂ {0, . . . , 2M} of forbidden offloading decisions. These

placement constraints are expressed as1

xil = 0, ∀l ∈ Li,∀i ∈ N . (3.3)

3.1.2 Local Processing and Task Parameters

The input data size, output data size, and required processing cycles of user i’s task are denoted by

Din(i), Dout(i), and Y (i) respectively. The processing time required by the local device is TLi , and

the energy consumption is ELi , both of which we assume are user-specific deterministic functions of

Din(i), Dout(i), and Y (i).

1Note that the placement constraints here are more flexible than that in Section 2.1, which implicitly requires thatM + j ∈ Li ⇐⇒ M ∈ Li using the current notation. While the formulation in Section 2.1 is practically sufficient formost systems (since it would make little sense why users would be forbidden from processing at a CAP while still beingallowed to access the remote cloud through that same CAP), we present here the more general case.


3.1.3 CAP Processing

CAP processing requires energy and time consumption for both the uplink and downlink transmission

of the task. The energy consumption for CAP processing from user i at CAP j can be expressed as

EAij = Etij + Erij , (3.4)

where Etij and Erij represent the uplink and downlink transmission energy costs respectively, and are

user-specific CAP-specific deterministic functions of Din(i), Dout(i) and Y (i).

The time requirement depends on the bandwidth and processing rate allocated to the user. Each

CAP has its own wireless channel for offloading. The uplink and downlink transmission times for user i

at CAP j are respectively

T tij =Din(i)

ηuijcuij

, (3.5)

T rij =Dout(i)

ηdijcdij

, (3.6)

where cuij and cdij are the assigned uplink and downlink bandwidths respectively, and ηuij and ηdij are the

spectral efficiencies of the uplink and downlink transmissions. The bandwidths cuij and cdij are constrained

by the bandwidth capacities CULj , CDL

j , and CTotalj :

N∑i=1

cuij ≤ CULj , (3.7)

N∑i=1

cdij ≤ CDLj , ∀j ∈M, (3.8)

N∑i=1

(cuij + cdij) ≤ CTotalj , ∀j ∈M. (3.9)

The processing time of task i at CAP j is

T aij =Y (i)

faij, (3.10)

where faij is the assigned processing rate for the task, constrained by the total processing rate available

at the CAP fAj :

N∑i=1

faij ≤ fAj , ∀j ∈M. (3.11)

3.1.4 Cloud Processing

In cloud processing, uplink/downlink transmission times and energy costs are identical to the CAP

processing case. There is however a further transmission between the CAP and the cloud T acij = (Din(i)+

Dout(i))/rac, where rac is a predetermined wired transmission rate between the CAP and the cloud. The

computation time is T ci = Y (i)/fCi , where fCi is a predetermined processing rate assigned to each user


at the cloud. The total cloud processing time is then

TCij = T tij + T rij + T acij + T ci . (3.12)

For energy consumption, we add to the transmission requirements a cloud utility cost CCi , with a relative

weight βi:

ECij = Etij + Erij + βiCCi . (3.13)

3.1.5 Individual and Social Cost Functions

Each user aims to minimize their individual cost, which can be any nondecreasing convex function of

energy and time consumption within the system, and is dependent on the offloading decision of the other

users.

The energy and time consumption for each user can be expressed as

Ei = ELi xi0 +

M∑j=1

EAijxij +

M∑j=1

ECijxi(j+M), (3.14)

Ti = TLi xi0 +

M∑j=1

TAij xij +

M∑j=1

TCij xi(j+M). (3.15)

Our individual cost function can now be expressed as

ui(x1, . . . ,xN ) = fi(E1, . . . , EN , T1, . . . , TN ). (3.16)

While in many cases individual users will only optimize for their own energy/time consumption, our

system allows for the more general case.

The social cost is a weighted linear sum of individual objectives,

U(x1, . . . ,xN ) =

N∑i=1

wiui, (3.17)

where wi > 0 is the weight for user i.

3.1.6 User Classes

Our model does not assume that the above parameters are identically distributed among the users. We

presume that the users in the system are clustered such that within each cluster, the users share similar

mobile devices, task characteristics, and physical locations. These classes may be derived from clustering

analysis on real-world data. Our system would then treat such users similarly for assigning resources

and utility costs, such that each user in a given offloading site would have the same expected energy and

time costs.

To formalize this, we consider a partition of N into K classes, K = {K1, . . . ,KK}. For each class Kk,

we make the following assumptions about the users within it:

1. All user and task parameters Din(i), Dout(i), Y (i), ηuij , and ηdij are random but independent and

identically distributed, with known distributions.


2. All users have the same function for determining TLi , ELi , Etij , and Erij , and these functions are

known.

The system responds accordingly to the users within a class, ensuring symmetric expected energy

and time consumption between the users within an offloading site. In particular, all users in a class are

assigned identical cloud processing rates fCi and cloud utility costs and weights CCi and βi. Additionally,

all users in a class at the same offloading site are allocated equal bandwidth and CAP processing rate,

and the amount allocated does not vary based on the identity of the users at each site.

Given these assumptions, the users no longer need to know the exact value of their system parameters—

knowledge of their class membership and their associated distributions is sufficient for rational decision

making. Thus, we now assume the users minimize over their expected individual cost given uncertain

task parameters. We also assume the system knows each user’s class membership and the associated

distributions, but not individual parameter values. We note however that it is not necessary for the

users within a class to share a common cost function or weights wi.

With the introduction of classes, we can now consider the aggregate of offloading decisions by the

users within classes. This is denoted by a (2M + 1)-tuple of positive integers,

xk = [xk0, xk1, . . . , xkM , xk(M+1), . . . , xk(2M)]T , (3.18)

where

xkj =∑i∈Kk

xij , ∀j ∈ {0, . . . , 2M}. (3.19)

Individual task parameters can now be expressed as expectations conditional on class:

Dπ(k) = E[Dπ(i)|i ∈ Kk], π ∈ {in, out}, (3.20)

Y (k) = E[Y (i)|i ∈ Kk]. (3.21)

Similarly,

{ELk , TLk , T ck} = E[{ELi , TLi , T ci }|i ∈ Kk], (3.22)

Eπkj = E[Eπij |i ∈ Kk], π ∈ {t, r, A,C}, (3.23)

Tπkj = E[Tπij |i ∈ Kk], π ∈ {ac,A,C}. (3.24)

We express resource allocation in terms of classes as follows, the couplet representing CAP and cloud

processing respectively:

cπkj = (cπA

kj , cπC

kj ), π ∈ {u, d},

=

( ∑i∈Kk

cπijxij ,∑i∈Kk

cπijxi(j+M)

), (3.25)

fakj =∑i∈Kk

faijxij . (3.26)

Using the fact that resource allocation must be equal for each user in the class, we re-express terms in


(3.6) and (3.10) as expectations,2

Tπkj = (Tπ

A

kj , TπC

kj ), π ∈ {t, r}, (3.27)

T tA

kj =Din(k)ηu∗kj xkj

cuA

kj

, T tC

kj =Din(k)ηu∗kj xk(j+M)

cuC

kj

, (3.28)

T rA

kj =Dout(k)ηd∗kj xkj

cdA

kj

, T rC

kj =Dout(k)ηd∗kj xk(j+M)

cdC

kj

, (3.29)

T akj =Y (k)xkjfakj

, (3.30)

where

ηπ∗kj = E[1/ηπij |i ∈ Kk], π ∈ {u, d}. (3.31)

And we rewrite constraints (3.7)-(3.9), and (3.11) as

K∑k=1

cuA

kj + cuC

kj ≤ CULj ∀j ∈M, (3.32)

K∑k=1

cdA

kj + cdC

kj ≤ CDLj , ∀j ∈M, (3.33)

K∑k=1

cuA

kj + cuC

kj + cdA

kj + cdC

kj ≤ CTotalj , ∀j ∈M, (3.34)

K∑k=1

fakj ≤ fAj , ∀j ∈M. (3.35)

The expected processing times TAkj and TCkj can now be expressed as

TAkj = T tA

kj + T rA

kj + T akj , (3.36)

TCkj = T tC

kj + T rC

kj + T ackj + T ck , (3.37)

and the total expected class energy and time consumption as

Ek = ELk xk0 +

M∑j=1

EAkjxkj +

M∑j=1

ECkjxk(j+M), (3.38)

Tk = TLk xk0 +

M∑j=1

TAkjxkj +

M∑j=1

TCkjxk(j+M). (3.39)

3.2 Class-Anonymous Offloading Game

We assume that the users in the resultant system have agency over their offloading decisions xi, and

that they rationally minimize their individual objective functions. Thus, this system can be analyzed

as a finite game—in particular, a class-anonymous (CA) game, given the class-based assumptions in

2Note that all terms in the (3.6) and (3.10) are statistically independent within the class.


Section 3.1.6. This offloading game is not guaranteed to have a PSNE, and the computation of an

MSNE is usually too complex, as previously explained. We therefore use the CE to derive a solution to

the offloading problem. However, computation of the optimal CE generally requires exponential time

and space with respect to the number of users. For CA games however, we show that polynomial time

and space computation of the optimal CE is possible, by expressing the game in a reduced form.

3.2.1 Offloading Game

Our system can be analyzed as a finite game G with structure

G = (N , {Xi}i∈N , {ui}i∈N ), (3.40)

where N is the player set consisting of N system users, Xi ⊆ X is the strategy set of each user i, and

ui is their corresponding cost function the user seeks to minimize. The strategy set Xi consists of all

possible offloading decisions available to the user—from Section 3.1.1, this can be represented as the set

{xi} subject to (3.2)-(3.3). We let S =∏Ni=1Xi denote the set of strategy profiles. The individual costs

ui are defined in (3.16).

Given the class-based symmetry between the users within a class, we assume the users do not dis-

tinguish between other users within a single class to compute their individual cost (but they may still

however distinguish themselves apart from the rest of their class). Thus, the cost function ui can now

be expressed in terms of user i’s strategy xi, and the class-based assignments x1 to xK . Let k(i) be the

class index of user i. Then, with slight abuse of notation, we re-express ui as follows:

ui(x1, . . . ,xN ) = ui(xi, x1, . . . , xk(i) − xi, . . . , xK)

= fi(Ei, E1, . . . , Ek(i) − Ei, . . . , EK , Ti, T1, . . . , Tk(i) − Ti, . . . , TK). (3.41)

We note that Ek’s and Tk’s are equal for every strategy profile whose xk’s are equal, given the system

response to the class-based structure of the users.

Because of this structure, offloading game (3.40) falls within the general category of CA games.

Definition 2 (Class-Anonymous Game). Consider a finite game G defined in (3.40). G is a class-

anonymous game of order K if there exists a partition K of N into K classes, K = {K1, . . . ,KK}, such

that for any two users m and n in the same class, if user m adopts strategy xm and user n xn, then the

cost experience by every other user is the same if m and n switch strategies and no other changes are

made.

We note that the special case of the CA game where K = 1 is termed an anonymous game [40]. An

optimal CE solution was given in [18] for this case, but it is not directly applicable to a CA game with

general K.

3.2.2 Correlated Equilibra

Given an arbitrary finite game G defined in (3.40), a CE is defined as follows [17]:

Definition 3 (Correlated Equilibrium). Let σ be a distribution on S, and let s = {x1, . . . ,xN} ∈ S be

a strategy profile drawn from σ. Then, σ is a correlated equilibrium if for all players i ∈ N , the expected


cost of playing strategy xi is no larger than that of any other strategy x′i ∈ Xi:

Es∼σ[ui(xi,x−i)|xi] ≤ Es∼σ[ui(x′i,x−i)|xi], ∀i ∈ N ,xi,x′i ∈ Xi. (3.42)

Note that the users do not know the strategies of the other users, only a respective conditional

probability distribution. The above condition can be expressed as the following set of equations:∑s∈S|xi

P (s)[ui(x′i,x−i)− ui(xi,x−i)] ≥ 0, ∀i ∈ N ,xi,x′i ∈ Xi, (3.43)

where P (s) denotes the probability of drawing strategy profile s from σ. Note that the set {P (s)}s∈Sforms the distribution σ, and that the CE conditions are all linear with respect to P (s). Thus, one

means of computing the CE is solving a linear feasibility program over variables P (s) with (3.43) as

constraints. There are∑Ni=1

(|Xi|2

)such constraints, which is polynomial in N and |Xi| [18]. Additionally,

the following constraints must be added, to ensure that σ is a distribution:

P (s) ≥ 0, ∀s ∈ S, (3.44)∑s∈S

P (s) = 1. (3.45)

Furthermore, from [17] we know the following:

Theorem 1. Every finite game has a correlated equilibrium.

Thus, a solution to the feasibility program is guaranteed to exist.

Since any distribution over S that satisfies (3.43)-(3.45) is a CE, we can find an optimal CE by

minimizing in expectation a social cost function U over the constraints. This CE is more easily computed

than an MSNE, and satisfies rationality conditions for selfish users, as the users have no incentive to

deviate from their assigned strategy so long as they expect other users to do the same. We remark that

the CE relies on an assumption that the users do not know the strategies of other users and thus cannot

respond accordingly, unlike in an MSNE. However, the users in a mobile offloading network are unlikely

to have or be able to obtain such information, rendering the CE sufficiently stable.

3.2.3 Reduced Form of the Class-Anonymous Game

Even though (42) gives a polynomial number of constraints in N and |Xi|, we still have |S| = O(|X |N ),

which implies an exponential time and space requirement to compute and store P (s). Thus, we need

a means to represent the strategy space of the game in a reduced form, despite the size of its normal

form. In the following, we adopt the reduced form definition from [18] to show that the optimal CE for

the proposed CA offloading game can be found in polynomial time and space complexity.

Definition 4 (p-equivalence). Consider a finite game G defined in (3.40). Let Qi = {q1i , . . . , q

rii }, i ∈ N

be a partition of S−i into ri sets. For a player i, two strategy profiles (xi,x−i) and (x′i,x′−i) ∈ S are

p-equivalent if xi = x′i and x−i and x′−i belong to the same partition set in Qi.

Definition 5 (Reduced Form). The set of partitions Q =⋃Ni=1Qi is a reduced form of G of size |Q| if

ui(xi,x−i) = ui(x′i,x′−i) for any p-equivalent pair of (xi,x−i) and (x′i,x

′−i).


With a reduced form of a game, the following theorem from [18] provides sufficient conditions for

polynomial time computation of an optimal CE:

Definition 6 (Separation Problem). Let Q be the reduced form of a game. The separation problem for

Q is as follows: given a mapping yi : (x, j) → Q,∀i ∈ N ,x ∈ Xi, j ∈ {1, . . . , ri}, decide whether there

exists a strategy profile s ∈ S such that ∑(i,x,j):s∈Si(x,j)

yi(x, j) < 0, (3.46)

where Si(x, j) is the set of all strategy profiles (xi,x−i) ∈ S such that xi = x and x−i ∈ qji .

Theorem 2. Let Q be the reduced form of a game. If the separation problem for Q has a polynomial

time solution, a CE that optimizes for a linear combination of individual player cost (i.e. the optimal

CE) can be computed in polynomial time in the size of Q.

We now derive a reduced form of the CA game. Let x−i ∈ S−i =∏i′ 6=iXi′ . Let X−i represent

the matrix form of (x1, . . . , xk(i) − xi, . . . , xK). Let ri be the total number of possible X−i’s. Let

Qi = {q1i , . . . , q

rii } be a partition of all possible x−i’s according to their associated X−i class assignments.

From the form of the individual cost function in (3.41), any two p-equivalent strategy profiles will

experience the same individual cost ui. Thus, from Definition 5, QK =⋃Ni=1Qi is a reduced form of G.

The individual cost function from (3.41) can now be expressed in terms of the reduced form, again with

slight abuse of notation,

ui(xi,x−i) = ui(xi, j) = fi(Ei, Ti,E−i(j),T−i(j)), (3.47)

where j indicates the set qji ∈ Qi that x−i belongs to, and E−i(j) and T−i(j) represent their associated

energy and time costs.

Lemma 2. The size of QK is polynomial with respect to the N .

Proof. Assume without loss of generality that Xi = X ,∀i ∈ N . Let X = |X |. Then, for each class k,

there are(|Kk|+X−1

X−1

)distinct assignments of the |Kk| players in class k into the X strategies. Thus, the

size of each partition Qi is

ri =

(|Kk(i)|+X − 2

X − 1

) K∏k=1,k 6=k(i)

(|Kk|+X − 1

X − 1

). (3.48)

Since |Kk| ≤ N ,

ri ≤K∏k=1

(N +X − 1

X − 1

),

= O((N +X)KX). (3.49)

Therefore,

|QK | =N∑i=1

ri = O(N(N +X)KX), (3.50)


which is polynomial with respect to N .

Using these properties, we can now prove the following:

Theorem 3. The separation problem (see Definition 6) for QK has a polynomial time solution.

Proof. We note that there are exactly N summation terms in (3.46), one for each player—thus, the

computation of each sum requires O(N) time.

To solve the separation problem, we take an arbitrary player i ∈ N , strategy x ∈ Xi, and partition

index j ∈ {1, . . . , ri}, and find the strategy profile in qji that minimizes the sum in (3.46). To do so,

construct a graph with X layers of N − 1 vertices representing the users and their possible strategies,

a path for every strategy profile in qji , and edges yi(x, j) from (3.46). The associated minimum cost

flow problem has a polynomial time solution, as the number of edges and vertices in the graph are

polynomial [41], and a solution to separation problem is successfully returned whenever the resultant

flow is negative. In the worst case, by iterating over all j ∈ {1, . . . , ri} in all strategies x ∈ Xi, all

strategy profiles in S have been accounted for and the separation problem is solved in polynomial time

(as ri is polynomial in N from (3.49)).

From this result, the following is a direct consequence of Theorem 2:

Theorem 4. Class-anonymous games of order K have a polynomial time and space solution for the

optimal CE.

3.3 Optimal Correlated Equilibrium Solution

In this section, we present a linear programming approach to compute the optimal CE in polynomial

time, which is amenable to distributed implementation via ADMM over multiple CAPS.

3.3.1 Linear Programming Solution to Offloading Game

Recall the social cost function (3.17):

U(x1, . . . ,xN ) =

N∑i=1

wiui. (3.51)

To find the optimal CE, we must optimize this cost in expectation over a distribution over S, and

represent that distribution over the reduced form of the game to ensure polynomial time and space

complexity. Consider the objective function

N∑i=1

wi

(ri∑j=1

∑x∈X

Pi(x, j)ui(x, j)

), (3.52)

where the objective variables Pi(x, j) form a distribution over Si(x, j) (defined in Definition 6), for

each user i ∈ N . We presume ui(x, j) is computed in advance ∀i ∈ N ,x ∈ Xi, j ∈ {1, . . . , ri}. Given

the bound of ri from (3.49), there are O(NX(N + X)KX) such calculations, and an equal number of

objective variables Pi(x, j), implying a polynomial space representation.


The constraints (3.43)-(3.45) directly extend as follows:

ri∑j=1

Pi(x, j)[ui(x′, j)− ui(x, j)] ≥ 0, ∀i ∈ N ,x,x′ ∈ X (3.53)

Pi(x, j) ≥ 0, ∀x ∈ X , j ∈ {1, . . . , ri} (3.54)

ri∑j=1

∑x∈X

Pi(x, j) = 1, ∀i ∈ N . (3.55)

While {Pi} is not itself a CE (which is a distribution over S), it may extend to a CE as follows [18]:

Definition 7. Let σ = {P (s)}s∈S be a distribution over S. Then, {Pi}i∈N extends to σ if {Pi} and σ

satisfies the following equation:

Pi(x, j) =∑

s∈Si(x,j)

P (s), ∀i,x, j, (3.56)

Lemma 3. Let σ = {P (s)}s∈S be a CE of G. Then, if {Pi}i∈N extends to σ, then {Pi}i∈N satisfies

constraints (3.53)-(3.55) with the objective function (3.52) equal to

N∑i=1

wi∑s∈S

ui(s)P (s), (3.57)

where ui(s) = ui(x, j) such that s ∈ Si(x, j).

Note that (3.57) is the expected value of social cost of the CE as defined in (3.51).

Lemma 4. If {Pi} extends to some distribution σ over S and satisfies (3.53)-(3.55), then σ is a CE

with expected social cost equal to (3.57).

However, as demonstrated by [18], a feasible solution to the LP above does not necessarily extend

to a distribution on S—the above problem is thus a relaxed version of the optimal CE problem. We

therefore need additional constraints to ensure that the solution to our LP extends to a CE.

Let the set of X ×K matrices Φ = {X = [x1, . . . , xK]} represent the set of all possible class-based

assignments of the users in X . The size of Φ is O((N +X)KX) like ri, for analogous reasons (see (3.49)).

Note that Xx,k equals the total number of users in class k adopting strategy x. Let the binary X ×Kmatrix Zx,k be defined such that

Zx,km,n =

1, m = x and n = k

0, otherwise.

Note that if Xx,k > 0, then X−Zx,k corresponds to a possible X−i,∀i ∈ Kk. Let Ji(X−Zx,k) = j such

that the class-based assignments in qji correspond to the assignments in X−i = X− Zx,k

We add a polynomial number of decision variables p(X), representing a distribution over X ∈ Φ. We

now add the following constraints to our LP:

p(X) ≥ 0, ∀X ∈ Φ, (3.58)∑x:Xx,k(i)>0

Pi(x, Ji(X− Zx,k(i))) = p(X), ∀i ∈ N , X ∈ Φ (3.59)


∑i∈Kk

Pi(x, Ji(X− Zx,k)) = Xx,kp(X), ∀Kk ∈ K, X ∈ Φ,x ∈ X , (3.60)

∑X∈Φ

p(X) = 1. (3.61)

Finally, we add the placement constraints:

Pi(x, j) = 0, ∀i ∈ N ,x ∈ Li. (3.62)

The linear program for computing the CE is now as follows:3

minPi,p

N∑i=1

wi

(ri∑j=1

∑x∈X

Pi(x, j)ui(x, j)

), (3.63)

s.t. (3.53)-(3.54), (3.58)-(3.62) ((3.55) is now redundant).

The following Lemma suggests that no optimality is lost in considering problem (3.63) to find the optimal

CE.:

Lemma 5. Let σ = {P (s)}s∈S be a CE of G. Let S(X) be the set of all strategy profiles in S where the

users are assigned according to X. Then, if (3.56) is satisfied, and

p(X) =∑

s∈S(X)

P (s), (3.64)

then {Pi} and {p} satisfy constraints (3.58)-(3.61)—thus, all CE are within the feasible set of (3.63).

Proof. Since {S(X)}X∈Φ is by definition a partition of S, (3.58) and (3.61) holds from the fact that P (s)

forms a distribution over S. (3.59) and (3.60) are both direct results from the law of total probability.

From this we now show how a CE can be achieved from the distributions {p} and {Pi}.

Theorem 5. For any class-anonymous game of order K, a feasible solution to (3.63) extends to a CE

σ, and a strategy profile from σ can be sampled in polynomial time.

Proof. To show this result, we develop an polynomial time algorithm that produces randomly a strategy

profile s ∈ S, whose resultant distribution σ = {P (s)} satisfies the results in (3.63)— that is:

Pr[s ∈ S(X)] =∑s∈S

P (s) = p(X), ∀X ∈ Φ, (3.65)

Pr[s ∈ Si(x, j)] =∑

s∈Si(x,j)

P (s) = Pi(x, j), ∀i ∈ N ,x ∈ Xi, j ∈ {1, . . . , ri}. (3.66)

The implicit distribution that results from this algorithm, σ, would then by Definition 7 be an extension

of {Pi}, ensuring that σ is CE as implied by Lemma 4, which must be optimal as per Lemma 3.

To generate a CE with such properties, we first sample X from Φ via the distribution {p(X)}. From

this, we construct K complete bipartite graphs (V1, V2, E)k, one for each class in K, where V1 consists

of one vertex for each user i in class Kk, and V2 contains Xx,k vertices for each strategy x in X . We

3Note that polynomial time performance of this program is only guaranteed through certain means such as the ellipsoidmethod [42], however many other LP methods can work in practice.


assign to each edge (V1, V2) a weight corresponding to their respective user i and strategy x, generating

a fractional perfect matching:

yk(i,x) =Pi(x, Ji(X− Zx,k))

Xx,kp(X). (3.67)

From (3.59), the sum of the weights incident to any user i is 1—similarly, from (3.60), the sum of the

weights for all vertices in V2 is 1. Thus, the weights of the graph can be expressed as a doubly stochastic

matrix, which under Birkhoff’s theorem, can be decomposed into a convex combination of O(V 2) perfect

matchings in polynomial time [43]. This decomposition then represents a probability distribution over

the perfect matchings, each of which is a possible assignment of the users in the class to the available

strategies. When one such matching is sampled over all classes, the result is a strategy profile in S.

The resultant implicit distribution σ clearly satisfies (3.65) from the initial sampling. To show that

(3.66) is satisfied, we note that the solution method results in the following probability of drawing a

strategy profile s ∈ Si(x, j):

Pr[s ∈ Si(x, j)] = Pr[s ∈ X∗]X∗x,kyk(i,x), (3.68)

= p(X∗)X∗x,kPi(x, j)

X∗x,kp(X∗), (3.69)

= Pi(x, j), ∀i ∈ N , j ∈ {1, . . . , ri},x ∈ X , (3.70)

where X∗ is the single value of X ∈ Φ such that S(X) ∩ Si(x, j) 6= ∅.

3.3.2 Resource Allocation Problem

In order to compute the LP presented above, individual costs ui must be computed ahead of time

according to (3.47). However, this cost depends on the associated resource allocation decisions for

bandwidth and CAP processing rate, which can vary according to the strategy profile. In order to

maintain the CA property of the game, resource allocations must be invariant for any set of strategy

profiles with identical class-based user assignments, in order to maintain constant expected energy and

time consumptions within the offloading site:

cπkj = cπkj(X), fakj = fakj(X), π ∈ {u, d}. (3.71)

As long as a resource allocation scheme satisfies this condition, the LP in (3.63) will compute the optimal

CE of the system under any such scheme.

One example of such a scheme is as follows. For any given strategy profile, we would ideally seek

to choose resource allocations that minimize (3.51), subject to (3.32)-(3.35) and positivity constraints.

However, the resultant optimization problem may violate class-anonymity, since wi’s and ui’s are not

symmetric within the class, and therefore U is not a function of X. Thus, to compute the resource

allocation, we must optimize for a modified social cost function U that is dependent only on X. For

example, U may be the weighted average social cost overall all possible permutations of the users in


assignment X,

U(X) =

K∑k=1

1

|Kk|∑i∈Kk

wi

2M∑j=0

xkj∑i∈Kk

wiui(xj , Ji(X− Zxj ,k)),

where xj is the strategy x corresponding to index j from (3.1). Then, the resource allocation problem

becomes

min{cu

k},{cdk},{f

ak }U(X), (3.72)

s.t. (3.32)-(3.35),

cuk , cdk, f

ak � 0, (3.73)

where cuk , cdk, and fak are the vectorized forms of cukj , c

dkj and fakj .

This is a convex optimization problem, since time consumption is a reciprocal function over the

positively constrained objective variables (energy consumption being fixed for each set offloading deci-

sions), ui is convex and nondecreasing over energy and time, and U is linear over ui. Thus, all resource

allocations and costs can be computed in polynomial time given a fixed offloading decision.

3.3.3 Distributed Computation by ADMM

While the LP (3.63) above can be solved directly, the problem still involves a large number of decision

variables and may require non-trivial computational complexity. However, we note that the problem

is separable with respect to the decision variables, and (3.63) allows for a distributed solution through

ADMM, as all conditions for convergence of ADMM are met: all separable components of the objective

function are closed, proper and convex, and the Lagrangian has a saddle point [44]. Because our system

contains multiple CAPs, each CAP can be allocated a given number of objective variables and jointly

compute the CE, potentially reducing the time required for this computation. Because our system is a

straightforward convex linear program, we adopt the classic algorithm for ADMM from [44] , converting

the inequality constraints through the penalty function, which is guaranteed to converge to the optimal

solution.

Thus we propose the following distributed computation of the optimal CE:

1. A central controller in the system obtains the cost function for each user in the system, and

determines a respective weighting factor for the social objective. Class information is also obtained,

either directly from the users or inferred through a clustering method.

2. The controller determines the assignments of all partitions in the reduced form Q of the system.

Using that, it solves the resource allocation problem (3.72) to compute all individual utilities

ui(x, j),x ∈ Xi, for the users along with the corresponding resource allocation values, storing

these values in a hash table for easy reference.

3. The controller assigns the objective variables among the CAPs in the system, which then solves

the (3.63) through ADMM.

4. The controller uses the resultant distributions to select probabilistically a single strategy profile,

which it then assigns to each user. Users then offload their task based on their given assignment.


Since we assume the users do not know the assignments given to the other users, by the properties

of the CE, the users have no incentive to deviate from their assignment.

3.4 Simulation Results

In this section, we evaluate the performance of the proposed optimal CE via simulation using real-world

system parameters. We first present performance comparison in a multi-CAP system with two alterna-

tives: Random Mapping, where offloading decisions are chosen randomly for each user; and Learned CE,

where a non-optimal CE is computed using the regret-based learning method detailed in [45]. We then

present a comparison with the MCAP solution method presented in Chapter 2 in a single-CAP system.

3.4.1 Multi-CAP System Results

Table 3.1 list the global system parameters (i.e. system parameters not dependent on class), where the

processing requirement is derived from x264 CBR encoding [38], local CPU speed is taken from the

iPhone X [39], transmitting and receiving energies are from [38], and the communication bandwidths

correspond to mid-spec WiFi systems. In each class, the input and output data are normally distributed

with a specified mean and variance. Spectral efficiencies are uniformly distributed with fixed minimum

and maximum values. We scaled the cloud utility cost Cci to the expected input data size Din(i). These

parameters are all listed for each class in Table 3.2.

We consider a system of three classes, with seven users per class, and two CAPs by default. Each user

shares the same individual cost function, defined as a weighted sum of energy and time consumption:

ui(x1, . . . ,xN ) = Ei + αTi, (3.74)

where α has unit J/s, so that ui is measured in the unit of J. We set α = 0.5 J/s by default. Our social

cost function is a simple sum of all user cost, with every user’s weight wi = 1.

Figures 3.1, 3.2, and 3.3 show the expected social cost, averaged over 40 trials, sweeping through

the number of users per class (from 6 to 8), α (from 0.1 to 0.9), and the number of CAPs (1 to 3)

respectively. In each of these figures, the proposed optimal CE achieves the best results, followed by the

non-optimal CE, and finally by random mapping. Figures 3.1 and 3.2 show an approximately linearly

increasing relationship between the expected cost and the number of users and α, both of which are to

be expected from the system model. Figure 3.3 shows a decreasing relationship between the expected

cost and the number of CAPs, which is due to the availability of additional offloading sites.

Figure 3.4 shows the costs experience for each particular class in the system against the number

of users. We observe that Class A has the highest cost, followed by Class B and Class C. This is in

accordance with Class A having the largest data size and lowest spectral efficiency, Class B with improved

spectral efficiency, and Class C a smaller data size.

3.4.2 MCAP Comparison

We now compare the results of the MCAP method presented in Chapter 2 with the CE method in a

single-CAP system (to limit the strategy space and thus reduce the simulation runtime). The default

parameters of the system are presented in Table 3.3, which were changed from Table 3.1 to match the


6 7 8

Number of Users per Class

400

450

500

550

600

650

700

Ex

pec

ted

Co

st (

J)Optimal CE

Learned CE

Random Mapping

Figure 3.1: Cost against number of users per class

Table 3.1: Global Parameter Values

Parameter Default ValueProcessing cycles per byte 1900

Number of CAPS 2βi 1.7 ×10−7,∀i

CjUL, CjDL 20 MHz, ∀j

CjTotal 40 MHz, ∀jLocal CPU speed 2.39× 109 cycles/sCAP CPU speed 5× 109 s/bit

Cloud CPU speed 7.5× 109 s/bitTx and Rx energy 1.42× 10−7 J/bit


parameter values of [13], where a single-CAP version of MCAP was also used as a comparison target.

We also compare with a random mapping of offloading decisions and the optimal solution, computed

through an exhaustive search.

We assume that the input and output data sizes are uniformly distributed between 10 and 30 MB and

1 and 3 MB respectively for all users, all spectral efficiencies are equal to 3.61 b/s/Hz, and αi = α = 0.5

s/J, ∀i. We consider the CE solution under two possible class-formulations: a single-class system model

(i.e. all the users are in the same class), and an N -class system model (i.e. all the users are in their own

distinct class). In the single-class CE system, we use the given distributions to compute the offloading

decision, while in the N -class CE system we use the exact task parameters of the users, as in MCAP.

MCAP requires the social cost function to take the following form (see (2.18)):


0.1 0.3 0.5 0.7 0.9

(J/s)

300

400

500

600

700

800

Expec

ted C

ost

(J)

Optimal CE

Learned CE

Random Mapping

Figure 3.2: Cost against α

Table 3.2: Class Parameter Values

Parameter Class A Class B Class CE[Din(i)] 48 MB 48 MB 24 MB

Var[Din(i)] 6× 107 6× 107 3× 107

E[Dout(i)] 6 MB 6 MB 3 MBVar[Dout(i)] 1× 107 1× 107 0.5× 107

Min ηuij , ηdij (b/s/Hz) 1 2 2

Max ηuij , ηdij (b/s/Hz) 2 4 4

U(X) =N∑i=1

αiEi + maxi′∈N

Ti′ . (3.75)

MCAP does not assume any particular form of the individual cost.4 However, an optimal CE solution

requires that social cost function to be expressible as a weighted sum of individual cost (see (3.17)).

Assuming all user weights wi = 1, we express the individual cost as follows for the single-class and the

N -class case.:

usingle-classi (X) = αE +

1

NT , (3.76)

uN-classi (X) = αEi +

1

Nmaxi′∈N

Ti′ . (3.77)

where E and T are the expected energy and time consumptions of all the users, which are equal for all

4MCAP-NE does require the individual cost function to be of the form in (2.70) in order for the system to be a potentialgame. However, this form of the individual cost is incompatible with (3.17). We therefore do not consider comparisonwith MCAP-NE as their solutions are incommensurable.


1 2 3

Number of CAPs

350

400

450

500

550

600

650

700

750

800

Ex

pec

ted

Co

st (

J)Optimal CE

Learned CE

Random Mapping

Figure 3.3: Cost against number of CAPs

Table 3.3: Global Parameter Values - MCAP Comparison

Parameter Default ValueProcessing cycles per byte 1900

Number of CAPS 1βi 3 ×10−7,∀i

CUL, CDL 20 MHzCTotal 40 MHz,

Local CPU speed 500× 106 cycles/sCAP CPU speed 2.5× 109 s/bit

Cloud CPU speed 5× 109 s/bitTx and Rx energy 1.42× 10−7 J/bit


users given that they all share the same class. We also note that the resource allocation problems in

2.18 for MCAP and in 3.72 for the CE solution are equivalent in the N -class model.

Figure 3.5 shows the expected social cost sweeping through 6 to 8 total users. In this figure we

show that both MCAP and the N -class CE perform near-optimally, with the single-class CE performing

considerably worse. This demonstrates that while our CE method can perform very well in practice under

a deterministic system, the system performance deteriorates when the variance of the class parameters

increases. However, even in the single-class system the CE performs considerably better than the random

mapping. This reinforces the viability of our solution method in cases of uncertain task parameters.

3.5 Summary

In this chapter, we study the CE for a three-tier mobile offloading network. Unlike the PSNE and the

MSNE, the CE is easily computable through linear programming for all systems with a finite offloading


6 7 8

Number of Users per Class

0

50

100

150

200

250

Ex

pec

ted

Co

st

of

Op

tim

al C

E (

J)

Class A

Class B

Class C

Figure 3.4: Class costs against number of users

space, and does not require the existence of a potential function for its computation. This enables a

more convenient solution for these systems, as opposed to the restrictive application of previous works.

In the class-anonymous setting where user parameters are clustered, we propose a method to compute

the optimal CE in polynomial time with respect to the number of users. Simulation results further

demonstrate the feasibility of our solution method, and its performance advantage in comparison with

common alternatives.


6 7 8

Number of Users

160

180

200

220

240

260

280

300

320

Co

st (

s)

Random Mapping

MCAP

Optimal CE (1 class)

Optimal CE (N classes)

Optimal Solution

Figure 3.5: Cost against number of users—Comparison with MCAP

Chapter 4

Conclusion

In this thesis, we study three-tier mobile offloading systems consisting of multiple CAPs. We consider

a centralized optimization approach using a relaxed SDP heuristic (MCAP), a NE approach using the

previous method as an initial starting point (MCAP-NE), and a CE approach under a more general set

of conditions for the individual and social objectives. Each of these approaches has its advantages and

disadvantages. MCAP is the fastest approach, but does not account for selfish users. MCAP-NE is the

most robust under a selfish user assumption, but is only applicable under a very specific formulation

of the individual and social objective functions. The CE approach is the most generally applicable

while still allowing for selfish users, but requires a class-based clustering of user parameters and device

characteristics to be feasible in systems with a high number of users.

Each of these approaches have the potential for future extensions. Regarding the centralized ap-

proach, there are possible new means of computing a near-optimal heuristic solution for the offloading

decision and resource allocation that may improve upon an SDP approach in either system performance

or required computational time. Additionally, the case of multiple tasks per round has not yet been

extended to multiple CAPs, nor has considerations such as multiple processors per CAP, uncertainty

in the task parameters, or online generation of tasks. Regarding the NE approach, the potential game

requirement to find a feasible NE solution under the finite improvement method necessitates new means

of finding the NE under broader conditions. There is also a lack of literature considering the computa-

tion of an MSNE in MEC systems, and the system properties required for feasible computation. One

possibility is the class-based symmetric game, a class-based generalization of the symmetric game, given

that an MSNE solution method for the symmetric game was presented outside the mobile offloading

context in [18]. Regarding the CE approach, there are potentially additional types of games from the

ones listed in [18] and the CA game presented here that allow for a polynomial computation of an opti-

mal CE—perhaps new varieties of graphical games, for example. Furthermore, there is an even broader

equilibrium concept called the coarse-correlated equilibrium (CCE), which may prove useful under an

even more general system model than a feasible CE solution method would allow for. The CCE ensures

that users have no incentive in expectation to deviate from their assigned strategy. Thus, the CCE

assumes that users do not in fact know the strategy being assigned to them (or have no opportunity to

deviate once their offloading decision has been assigned). This may be acceptable in systems with many

CAPs and servers, where the mobile users may not know how or where the system is processing their

task, but is nonetheless incentivised to follow the system’s decisions under this uncertainty.

50

Bibliography

[1] K. Kumar, J. Liu, Y.-H. Lu, and B. Bhargava, “A survey of computation offloading for mobile

systems,” Mobile Networks and Applications, vol. 18, no. 1, pp. 129–140, Feb. 2013.

[2] “Amazon EC2,” https://aws.amazon.com/ec2/, [Online; accessed 05-2019].

[3] Y. Mao, C. You, J. Zhang, K. Huang, and K. B. Letaief, “A survey on mobile edge computing: The

communication perspective,” IEEE Commun. Surveys Tuts., vol. 19, no. 4, pp. 2322–2358, Aug.

2017.

[4] B. Liang, “Mobile edge computing,” in Key Technologies for 5G Wireless Systems, V. Wong,

R. Schober, D. Ng, and L. Wang, Eds. Cambridge University Press, 2017.

[5] ETSI Group Specification, “Mobile edge computing (MEC); framework and reference architecture,”

ETSI GS MEC 003 V1.1.1, Mar. 2016.

[6] A. Greenberg, J. Hamilton, D. A. Maltz, and P. Patel, “The cost of a cloud: Research problems

in data center networks,” ACM SIGCOMM Computer Communication Review, vol. 39, no. 1, pp.

68–73, Dec. 2008.

[7] M. Satyanarayanan, P. Bahl, R. Caceres, and N. Davies, “The case for vm-based cloudlets in mobile

computing,” IEEE Pervasive Computing, vol. 8, no. 4, pp. 14–23, Oct. 2009.

[8] F. Bonomi, R. Milito, J. Zhu, and S. Addepalli, “Fog computing and its role in the internet of

things,” in Proc. ACM SIGCOMM Workship on Mobile Cloud Computing, Aug. 2012, pp. 13–16.

[9] M.-H. Chen, M. Dong, and B. Liang, “Joint offloading decision and resource allocation for mobile

cloud with computing access point,” in Proc. IEEE International Conference on Acoustics, Speech

and Signal Processing (ICASSP), Mar. 2016, pp. 3516–3520.

[10] M.-H. Chen, B. Liang, and M. Dong, “Resource sharing of a computing access point for multi-user

mobile cloud offloading with delay constraints,” IEEE Transactions on Mobile Computing, vol. 17,

no. 12, pp. 2868–2881, Mar. 2018.

[11] ——, “Joint offloading and resource allocation for computation and communication in mobile cloud

with computing access point,” in Proc. IEEE Conference on Computer Communications (INFO-

COM), May 2017.

[12] ——, “Multi-user multi-task offloading and resource allocation in mobile cloud systems,” IEEE

Transactions on Wireless Communications, vol. 17, no. 10, pp. 6790–6805, Oct. 2018.

51

Bibliography 52

[13] M.-H. Chen, M. Dong, and B. Liang, “Multi-user mobile cloud offloading game with computing

access point,” in Proc. IEEE International Conference on Cloud Networking (CLOUDNET), Oct.

2016.

[14] Q. D. La, Y. H. Chey, and B.-H. Soong, Potential Game Theory. Springer International Publishing,

2016.

[15] C. Daskalakis, P. W. Goldberg, and Papadimitriou, “The complexity of computing a nash equilib-

rium,” SIAM Journal on Computing, vol. 39, no. 1, pp. 195–259, May 2009.

[16] Z.-Q. Luo, W.-K. Ma, A.-C. So, Y. Ye, and S. Zhang, “Semidefinite relaxation of quadratic opti-

mization problems,” IEEE Signal Processing Magazine, vol. 27, pp. 20–34, 2010.

[17] R. J. Aumann, “Subjectivity and correlation in randomized strategies,” Journal of Mathematical

Economics, vol. 1, no. 1, pp. 67–96, Mar 1974.

[18] C. H. Papadimitriou and T. Roughgarden, “Computing correlated equilibria in multi-player games,”

Journal of the ACM, vol. 55, no. 3, pp. 1–29, Jul. 2008.

[19] W. Zhang, Y. Wen, K. Guan, D. Kilper, H. Luo, and D. Wu, “Energy-optimal mobile cloud comput-

ing under stochastic wireless channel,” IEEE Transactions on Wireless Communications, vol. 12,

no. 9, pp. 4569–4581, Sep. 2013.

[20] S. Barbarossa, S. Sardellitti, and P. Di Lorenzo, “Computation offloading for mobile cloud com-

puting based on wide cross-layer optimization,” in Proc. Future Network and Mobile Summit, Jul.

2013.

[21] W. Zhang, Y. Wen, and D. O. Wu, “Energy-efficient scheduling policy for collaborative execution in

mobile cloud computing,” in Proc. IEEE International Conference on Computer Communications

(INFOCOM), Apr. 2013.

[22] M.-H. Chen, B. Liang, and M. Dong, “Joint offloading decision and resource allocation for multi-

user multi-task mobile cloud,” in Proc. IEEE International Conference on Communications (ICC),

May 2016.

[23] O. Munoz, A. Pascual-Iserte, and J. Vidal, “Optimization of radio and computational resources for

energy efficiency in latency-constrained application offloading,” IEEE Transactions on Vehicular

Technology, vol. 64, no. 10, pp. 4738–4755, Nov. 2014.

[24] R. M. R., N. Venkatasubramanian, S. Mehrotra, and A. V. Vasilakos, “Mapcloud: Mobile appli-

cations on an elastic and scalable 2-tier cloud architecture,” in Proc. IEEE/ACM International

Conference on Utility and Cloud Computing, Nov. 2012.

[25] R. M. R., N. Venkatasubramanian, and A. V. Vasilakos, ““music: Mobility-aware optimal service al-

location in mobile cloud computing,” in Proc. IEEE International Conference on Cloud Computing,

Jun. 2013.

[26] J. Song, Y. Cui, M. Li, J. Qiu, and R. Buyya, ““energy-traffic tradeoff cooperative offloading for

mobile cloud computing,” in Proc. IEEE International Symposium of Quality of Servous (IWQoS),

May 2014.

Bibliography 53

[27] V. Cardellini, V. D. N. Persone, V. D. Valerio, F. Facchinei, V. Grassi, F. L. Pressit, and V. Piccialli,

“A game-theoretic approach to computation offloading in mobile cloud computing,” Mathematical

Programming, pp. 1–29, Apr. 2015.

[28] Y. Wang, X. Lin, and M. Pedram, “A nested two stage game-based optimization framework in

mobile cloud computing system,” in Proc. IEEE International Symposium on Service Oriented

System Engineering (SOSE), Mar. 2013.

[29] S. Josilo and G. Dan, “A game theoretic analysis of selfish mobile computation offloading,” in Proc.

IEEE Conference on Computer Communications (INFOCOM), May 2017.

[30] E. Meskar, T. Todd, D. Zhao, and G. Karakostas, “Energy efficient offloading for competing users

on a shared communication channel,” in Proc. IEEE International Conference on Communications

(ICC), Jun. 2015.

[31] X. Ma, C. Lin, X. Xiang, and C. Chen, “Game-theoretic analysis of computation offloading for

cloudlet-based mobile cloud computing,” in Proc. of ACM MSWiM, Nov. 2015.

[32] X. Chen, “Decentralized computation offloading game for mobile cloud computing,” IEEE Trans-

actions on Parallel and Distributed Systems, vol. 26, no. 4, pp. 974–983, Apr. 2015.

[33] 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, Oct.

2015.

[34] S. Josilo and G. Dan, “Wireless and computing resource allocation for selfish computation offloading

in edge computing,” in Proc. IEEE Conference on Computer Communications (INFOCOM), Apr.

2019.

[35] H. Cao and J. Cai, “Distributed multi-user computation offloading for cloudlet based mobile cloud

computing: A game-theoretic machine learning approach,” IEEE Transactions on Vehicular Tech-

nology, vol. 67, no. 1, pp. 752–764, Aug. 2017.

[36] D. Monderer and L. S. Shapley, “Potential games,” Games and Economic Behavior, vol. 14, no. 1,

pp. 124–143, Jun. 1996.

[37] M.-H. Chen, “Joint task offloading and resource allocation for mobile cloud with computing access

point,” Ph.D. dissertation, University of Toronto, Toronto, ON, CA, 2017.

[38] A. P. Miettinen and J. K. Nurminen, “Energy efficiency of mobile clients in cloud computing,” in

Proc. USENIX Conference on Hot Topics in Cloud Computing (HotCloud), Jun. 2010.

[39] ubergizmo.com, “Apple iphone x specifications,” 2017, accessed 2019-07-31. [Online]. Available:

https://www.ubergizmo.com/products/lang/en us/devices/iphone-x/

[40] M. Blonski, “Characterization of pure-strategy equilibria in finite anonymous games,” Journal of

Mathematical Economics, vol. 34, no. 2, pp. 225–233, Oct 2000.

[41] R. K. Ahuja, T. L. Magnanti, and J. B. Orlin, Network Flows: Theory, Algorithms, and Applications.

Prentice-Hall Inc., 1993.

Bibliography 54

[42] B. Randol, “The ellipsoid method in linear programming,” Advances in Applied Mathematics, vol. 1,

no. 1, pp. 1–6, Mar. 1980.

[43] R. A. Brualdi, “Notes on the birkhoff algorithm for doubly stochastic matrices,” Canadian Mathe-

matical Bulletin, vol. 25, no. 2, pp. 191–199, Jun. 1982.

[44] S. Boyd, N. Parikh, E. Chu, and J. Peleato, Eckstein, “Distributed optimization and statistical

learning via the alternating direction method of multipliers,” Foundations and Trends in Machine

Learning, vol. 3, no. 1, pp. 1–122, Jan. 2011.

[45] S. Hart and A. Mas-Collel, “A simple adaptive procedure leading to correlated equilibrium,” Econo-

metrica, vol. 68, no. 5, pp. 1127–1150, Sep. 2000.

Documents

Offloading and Resource Allocation in Mobile Edge