A Market-Based Framework for Multi-Resource Allocation in Fog Computing

by   Duong Tung Nguyen, et al.

Fog computing is transforming the network edge into an intelligent platform by bringing storage, computing, control, and networking functions closer to end-users, things, and sensors. How to allocate multiple resource types (e.g., CPU, memory, bandwidth) of capacity-limited heterogeneous fog nodes to competing services with diverse requirements and preferences in a fair and efficient manner is a challenging task. To this end, we propose a novel market-based resource allocation framework in which the services act as buyers and fog resources act as divisible goods in the market. The proposed framework aims to compute a market equilibrium (ME) solution at which every service obtains its favorite resource bundle under the budget constraint while the system achieves high resource utilization. This work extends the General Equilibrium literature by considering a practical case of satiated utility functions. Also, we introduce the notions of non-wastefulness and frugality for equilibrium selection, and rigorously demonstrate that all the non-wasteful and frugal ME are the optimal solutions to a convex program. Furthermore, the proposed equilibrium is shown to possess salient fairness properties including envy-freeness, sharing-incentive, and proportionality. Another major contribution of this work is to develop a privacy-preserving distributed algorithm, which is of independent interest, for computing an ME while allowing market participants to obfuscate their private information. Finally, extensive performance evaluation is conducted to verify our theoretical analyses.



There are no comments yet.


page 1

page 2

page 3

page 4


Price-based Resource Allocation for Edge Computing: A Market Equilibrium Approach

The emerging edge computing paradigm promises to deliver superior user e...

Efficient Network Sharing with Asymmetric Constraint Information

Network sharing has become a key feature of various enablers of the next...

Joint Management of Compute and Radio Resources in Mobile Edge Computing: a Market Equilibrium Approach

Edge computing has been recently introduced as a way to bring computatio...

Distributed Resource Allocation for Network Slicing of Bandwidth and Computational Resource

Network slicing has been considered as one of the key enablers for 5G to...

Toward a Market Model for Bayesian Inference

We present a methodology for representing probabilistic relationships in...

Adaptive Fog Configuration for the Industrial Internet of Things

Industrial Fog computing deploys various industrial services, such as au...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

I Introduction

Fog Computing (FC), also known as Edge Computing (EC), is an emerging paradigm that complements the cloud to enable a wide range of Internet of Things (IoT) applications, reduce network traffic, and enhance user experience. By distributing storage, computing, control, and networking functions closer to end-users and data sources, FC enjoys many remarkable capabilities, including local data processing and analytics, distributed caching, localization, resource pooling and scaling, enhanced privacy and security, and reliable connectivity [1, 2]

. Additionally, FC is the key to meeting the stringent requirements of new systems and low-latency applications such as embedded artificial intelligence, 5G networks, virtual/augmented reality (VR/AR), and tactile Internet.

Despite the tremendous potential, FC is still in its infancy stage and many challenges remain to be addressed. In this paper, we focus on the fog resource allocation problem where a resource pool consisting of multiple Fog Nodes (FN) is shared among different services. Here, we consider an FN as any edge node consisting of one or more computing units (e.g., edge clouds, micro data centers in campus buildings, enterprises, hospitals, malls, and telecom central offices, servers at base stations, and idle PCs in research labs) [1, 2, 3]. Unlike the traditional cloud with virtually infinite capacity, FNs have limited computational power. They also come with different sizes and configurations. Furthermore, in contrast to a small number of cloud data centers (DC), there are numerous distributed FNs [3]. Due to the heterogeneity of the FNs in terms of location, specifications, reliability, and reputation, the services may have diverse preferences towards them. For example, a service may prefer an FN with powerful hardware and geographically close to it.

Therefore, a primary concern is how to efficiently allocate the limited fog resources to the competing services with diverse characteristics and preferences, considering the service priority and fairness. To address this problem, we propose a new market-based framework whose goal is to harmonize the interests of different market participants so that every service is happy with its allotment while the system maintains high resource utilization. The core idea is to assign different prices to resources of different FNs. Specifically, under-demanded resources are priced low while over-demanded resources have high prices. In our model, each service has a certain budget for resource procurement, which represents the service’s priority level and can be interpreted as the market power of the service [3]. Given the resource prices, each service buys an optimal resource bundle to maximize its utility under the budget constraint. When the market clears, the resulting prices and allocation form a market equilibrium (ME) [4, 5].

The proposed model is motivated by many real-world scenarios [3]. For instance, to divide fog resources among multiple network slices [6], a Telco can grant different budgets to the slices depending on their importance and potential revenue generation (e.g., the total fee paid by the users of each slice). Similarly, using virtual budgets, different labs/departments in a university can fairly share the fog resources located on their campus. Additionally, a service provider (e.g., Uber, Pokemon Go, a sensor network), who owns a set of FNs in a city, may allocate virtual budgets to different groups of users/sensors based on their populations in different areas. Another example inspired by the group buying concept is that several companies (i.e., services) may agree upfront on their individual budgets, then buy/rent a set of FNs together. Instead, these companies can pay subscription fees (i.e., budgets) to use fog resources of a platform that manages a resource pool. This is quite similar to the current postpaid mobile plan models.

For the settings described above, it is necessary to consider both system efficiency and fairness. Therefore, traditional solutions such as welfare maximization, maxmin fairness, and auction may not be suitable [3]. For instance, a welfare maximization solution, which is also often the design goal of many auction models [7], typically allocates most of the resources to agents with high marginal gains while giving very little, even nothing, to agents with low marginal utilities. Thus, it may not be fair to some agents. On the other hands, a maxmin fairness allocation often gives too many resources to agents with low marginal utilities, hence, it may not be efficient. Different from these approaches, our proposed market-based solution is both fair and efficient. In particular, we formulate the fog resource allocation problem as a Fisher market where the services act as buyers and the fog resources are divisible goods.

Since there are multiple goods and the purchase decision of each buyer depends on all these goods (both prices and the buyer’s preferences towards them), the proposed problem is inherently a General Equilibrium (GE) problem [4]. The existence of an ME in the GE model was established under some mild conditions (e.g., locally non-satiated utilities) in the seminal work of Arrow and Debreu [8]. Unfortunately, their proof relies on fixed-point theorem and does not give an algorithm to compute an equilibrium [5]. Hence, the algorithmic aspects of the GE theory have recently drawn a lot of interests from theoretical computer scientists [9, 10, 11, 12, 46]. However, there is still no general technique for equilibrium computation [11]. The strategic behavior of agents in the Fisher market game has also been studied extensively recently [47, 49, 48, 50].

Conventionally, the dual variables associated with the resource capacity constraints are often interpreted as the resource prices [13]. Thus, without budget consideration, popular techniques such as network utility maximization (NUM) [14] can be employed to compute an ME. However, these techniques do not work for the Fisher market. The main challenge stems from the budget constraints and the market clearing condition that couple the allocation decision (i.e., primal variables) and the prices (i.e., dual variables). Fortunately, for a wide class of utility functions, the ME in a Fisher market can be found by solving an Eisenberg-Gale (EG) program [15, 5].

Unlike the previous works, we focus on a practical setting where the services have utility limits due to their limited demands (e.g., the request rate of a service in a given area is not unlimited). This violates the implicit assumption in the GE literature that requires the utility function is non-satiated (i.e., for any bundle of goods, there is always another bundle of goods that is strictly improve the utility [4]). Also, because of the limited demand constraint, the services’ utility functions do not satisfy the conditions of the EG program. Our work aims to understand the ME concept in this setting.

While an ME solution is highly desirable, multiple equilibria may exist. Indeed, when we consider the utility limit, the allocation at some equilibrium can be wasteful and non-Pareto efficient as discussed in III-B2. Hence, we impose additional criteria to select an ME with some good properties. Specifically, an allocation should be non-wasteful and frugal. An allocation is non-wasteful if no resources desired by any service are left unallocated and no service receives resources that it has no use for [17, 16]. The frugality property implies that services want to maximize their utilities while spending less money. Note that the non-wastefulness and frugality concepts do not exist in the traditional Fisher market. The proposed framework allows us to compute a non-wasteful and frugal ME, which implies the allocation is efficient.

We further connect the equilibrium to the fair division literature [18]. Specifically, the proposed ME is shown to have appealing fairness properties including envy-freeness, sharing-incentive, and proportionality [17, 18]. Indeed, these properties were seldom studied in the ME literature. Note that, in general, not every ME satisfies these properties. In this work, we do not pursue strategy-proofness and assume that the services are price-takers. This assumption is reasonable in an environment with a large number of agents. Furthermore, we develop a privacy-preserving distributed algorithm for equilibrium computation, which prevents adversaries from learning private information (even statistical information) of the services, hence, alleviates the necessity of the strategy-proofness requirement. To the best of our knowledge, this is one of the first parallel and distributed algorithms implemented in a privacy-preserving manner. This algorithm is quite general and may find applications in other scenarios as well.

Although this work is closely related to our previous work [3], there are several fundamental differences. First, [3] considers the Fisher market with linear utilities and single resource type. Here, we study more complex utility functions and multiple resource types. Second, [3] aims to address the non-uniqueness of optimal bundles in designing distributed algorithms and equilibrium computation in the net profit maximization case. On the other hands, the purpose of this work is to investigate the ME concept in a market with utility limits. Additionally, in [3], the utility of every service is unique across all the market equilibria. However, it is not the case with our model. This work also introduces the new notions of non-wastefulness and frugality for equilibrium selection. Furthermore, we devise a privacy-preserving distributed algorithm for computing an ME. Our main contributions include:

  • Modeling. We formulate a new multi-resource allocation (MRA) problem in FC with budget-constrained agents. The problem is cast as a Fisher market and we advocate the GE. We are among the first explicitly tackle the MRA problem in the general setting with multiple nodes, each has multiple resource types, and multiple agents with finite demands [17].

  • Centralized solution. We theoretically extend the GE literature to consider the practical case where services have utility limits. We show that all non-wasteful and frugal market equilibria can be captured by a convex program. Furthermore, the proposed equilibrium is proved to have remarkable fairness properties.

  • Decentralized algorithms. By blending the alternating direction method of multipliers (ADMM) method with auxiliary variables and an efficient privacy-preserving averaging technique, we derive a parallel and distributed algorithm that converges to a non-wasteful and frugal ME while preserving the services’ privacy.

  • Performance Evaluation. Extensive simulations are conducted to confirm our theoretical results and demonstrate the efficacy of the proposed techniques.

The rest of the paper is organized as follows. The system model and problem formulation are given in Section II. Section III presents centralized solutions for computing an ME and analyzes the properties of the ME. The privacy-preserving distributed algorithm for computing the ME is introduced in Section IV. Finally, simulation results are shown in Section V followed by the discussion of related work in Section VI, and conclusions and future work in Section VII.

Ii System Model and Problem Formulation

Ii-a System Model

Fig. 1: System model

With FC, besides local execution and remote processing at cloud DCs, requests and data from end-devices (e.g., smartphones, PCs, sensors) can be handled by a fog network. Typically, a request first goes to a Point of Aggregation (e.g., switches/routers, base stations, access points), then it will be routed to an FN for processing. In practice, enterprises, factories, organizations (e.g., malls, schools, hospitals), and other third parties (e.g., sensor network owners) can outsource their services and computation to a fog network. Also, content/application/service providers (e.g., Google, Netflix, Uber, AR companies) can proactively place their data and applications onto FNs to serve better their customers.

In this work, we consider a system that consists of multiple services and a set of resource-constrained heterogeneous FNs. The system size may correspond to a metropolitan area network. Each service has a certain budget for resource procurement and wants to offload as many requests as possible to the fog network. The services are assumed to be price-takers, which is reasonable for a large market with multiple services. Each FN provides multiple resource types such as CPU, memory, and bandwidth (BW). We assume that there is a platform lying between the services and the FNs (i.e., the fog resource pool). Based on the information collected from the FNs (e.g., capacities) and the services (e.g., budget, preference, demand), the platform computes an ME solution that assigns a price to every fog resource and allocates an optimal resource bundle to every service. Each service can obtain information about the prices and its allocated resources from the platform. Also, the platform may control and manage the resource pool to implement the allocation decision. Fig. 1 presents the system model.

We assume that the requests (e.g., Apple Siri, Google Voice Search, weather/maps queries, AR, IoT data collection) are independent and each request requires resources in a specific ratio [19, 20, 21, 17, 22]. The amount of resources at an FN needed to handle a request of a service is called the base demand

of that service at the FN. For example, if a request of service A needs 0.2 units of CPU and 0.1 units of RAM at FN B, its base demand vector at FN B is (CPU: 0.2, RAM: 0.1). The number of requests of a service can be served is proportional to the amount of resources allocated to it. For instance, if service A receives 0.4 units of CPU and 0.3 units of RAM from FN B, it can process two requests (i.e., min

). Our model allows a service to specify different base demand vectors at different FNs to express its diverse preferences towards the fog resources.

Ii-B Service Utility Model

We denote the sets of FNs and services by and , respectively. The corresponding numbers of FNs and services are and . Let be the set of different types of resources. Define , , and as the service index, FN index, and resource type. The capacity of resource type at FN is . The base demand vector of service for resources of FN is where is the amount of resource type at FN required to process one request of service . For simplicity in presentation, we assume that . Note that all results in this paper still hold if . Due to different hardware specifications and locations of the FNs, the base demand vectors of a service at different FNs can be different. For example, a service may set higher values for bandwidth and computing resources in its base demand vector at an FN far away from it to ensure low latency.

Define as the amount of resource type at FN allocated to service and as the vector of resources allocated to service from FN . The resource bundle that service receives from the FNs is . Each bundle is a matrix where each row represents resources of an FN and each column represents a resource type. As explained in the system model, given , the number of requests of service that can be processed by FN is [19, 20, 21, 22]


Thus, given resource bundle , the total number of requests that the fog network can process for service is


In practice, a service may not have infinite demand (i.e., number of requests over a certain period). Let be the maximum demand of service . Then, the actual number of requests of service processed by the FNs is


The utility function of a service maps each resource bundle to a number quantifying the service’s valuation for that bundle. Define the utility function of service as . Let be the gain of service for each request processed by the fog network. We have:


Without loss of generality, we assume = 1, As can be seen later, the proposed allocation scheme is scale-free and independent of . Then, we have:


where and . We call the utility limit of service .

Note that a service may want to be served by only a subset of FNs that satisfy certain criteria (e.g., in terms of hardware specifications, reliability, and communication distance). For instance, a latency-sensitive service may be interested in only FNs that are geographically close to it. In this case, we have and . For simplicity of notations, we do not consider this constraint and assume . Indeed, the subsequent analysis and solution approaches remain unchanged if we consider this constraint.

Ii-C Fog Computing Resource Allocation Problem

We cast the problem as a Fisher market where the services act as buyers111The words ”service” and ”buyer” are used interchangeably in this paper. and the fog resources act as divisible goods. The market aims to price and allocate the resources to the services effectively. Denote by the price vector of resources of FN where is the price of of one unit of resource type at FN . Let capture the resource prices of all the FNs. Define as the budget of service . The optimal (i.e., utility-maximizing) resource bundle of service at prices can be found by solving the following service utility maximization problem.

subject to (8)

where (8) captures the budget limit of service . Note that each service computes its optimal resource bundle based simply on the resource prices and it does not care about the resource capacity constraints of the FNs. From the definition of the service utility function given in (5), we can rewrite the optimization problem (6)-(8) of each service as follows.

subject to (13)

Problem Statement: The proposed scheme aims to find an ME solution (, ) consisting of equilibrium prices and equilibrium allocation . At the equilibrium, every service receives its optimal resource bundle. In other words, is a utility-maximizing resource bundle of service at the equilibrium prices . Additionally, we would like to achieve high utilization of the available fog resources. The definition of an ME is formally given as follows [5].

Definition II.1

(,) is an ME if the two following conditions hold [5].

  • Service Satisfaction Condition: Given a non-negative price vector , every service receives its favorite resource bundle that maximizes its utility under the budget constraint. In other words, is an optimal solution to the problem (6)-(8) with , i.e., we have:

  • Market-Clearing Condition: Every fog resource is either fully allocated or has zero price, i.e., we have: .

These two conditions ensure that the equilibrium allocation maximizes the happiness of every service while maintaining high resource utilization. The second condition presents Walras’ law [5, 4] which states that all fog resources with positive prices () are fully allocated () and the remaining resources (i.e., not fully allocated) have zero prices. Indeed, due to zero prices, these resources can be allocated arbitrarily to the services without violating the budget constraints. Also, this additional allocation does not strictly improve the utility of any service since is already a utility-maximizing resource bundle of service among all its affordable bundles (i.e., following the service satisfaction condition). Hence, we can understand that the market clears.

In our problem, the services are players competing for the limited fog resources, while the platform tries to satisfy the market clearing condition. Prices are used to coordinate the market. Without loss of generality, we normalize the resource capacities of the FNs, i.e., we have:


The prices and the base demand vectors of the services can be scaled accordingly. This normalization is just to follow the standard market equilibrium literature [5, 9], and to simplify expressions and equations in the paper.

It is worth emphasizing that (6)-(8) or equivalently (9)–(13) is the optimization problem of individual services while the market/platform (not the services) needs to ensure the global constraints including the market-clearing condition and the resource capacity constraints as follows:


Our design goal is to find an ME (, ) that simultaneously maximizes the utility of every service (i.e., is an optimal solution of (6)-(8) with ) while satisfying the global constraints (16)-(17).

Iii Centralized Solution Approach

This section presents centralized solutions for computing market equilibria of the proposed problem. First, we briefly introduce the Fisher market and the Eisenberg–Gale (EG) program for computing ME when the services’ utility functions are concave and homogeneous of degree one222A function is homogeneous of degree if . [5, 4]. However, due to the finite demands of the services, their utilities are not homogeneous. We show that the optimal solution of the EG program for services with infinite demands is still an ME of our model for services with finite demands. However, this equilibrium allocation can be wasteful. Then, we rigorously demonstrate that all the non-wasteful and frugal market equilibria of our model can be captured by a convex program which is a natural generalization of the EG program. Furthermore, we show compelling fairness features of the ME solution obtained from this convex program.

Iii-a The Eisenberg-Gale Program

Consider a Fisher market with buyers and divisible goods with unit capacities. Let and be the buyer index and goods index. Buyer is characterized by budget and a utility function where is the vector of resources allocated to buyer . If the buyers’ utility functions are all concave and homogeneous of degree one, the optimal solution of the following EG program is an exact ME of this Fisher market [15, 5].

subject to (20)

Specifically, let () be an optimal solution of the EG program (18)-(20) where is the dual variables associated with constraint (20). Then, for every buyer , maximizes under the budget constraint and . Furthermore, the market-clearing condition is satisfied, i.e.,

Many well-known functions, such as linear, Cobb-Douglas, and Leontief, satisfy both concavity and homogeneity of degree one [5]. A function is linear if A Cobb-Douglas function has the form where . Finally, a Leontief function has the form . Another popular class of homogeneous utility functions is the Constant Elasticity of Substitution (CES) function [5, 4].

Iii-B Centralized Solution

We now return to our resource allocation problem. It can be observed that the service utility function in (5) is a combination of linear and Leontief functions (i.e., sum of Leontief functions ). Additionally, the utility limit makes this function more complex.

Iii-B1 Services with Infinite Demands

First, we consider the case in which services have unlimited demands. Then, from (5), the utility of service becomes

Proposition III.1

If a service has infinite demand, its utility function is concave and homogeneous of degree one.

Proof. Please refer to Appendix -A.

Thus, we can directly apply the EG program (18)-(20), where goods corresponds to resource type of FN and each service is a buyer, and have the following corollary.

Corollary III.2

If all the services have infinite demands, the optimal solution of the following problem

subject to (24)

is an exact ME of our fog resource allocation problem.

Iii-B2 Services with Finite Demands

When the services have limited demands, which is often the case in practice, it is easy to see that the utility function in (5) is not homogeneous. For example, when a service reaches its utility limit, its utility remains unchanged when we double the amount of resources allocated to it. We show that the optimal solution to (22)-(24) is still an ME of the proposed resource allocation model where services have finite demands (i.e., utility limits). However, this solution may lead to a wasteful allocation because some services may receive too many resources at the equilibrium without improving their utilities. An allocation is non-wasteful if: i) the remaining resources after the allocation cannot improve the utility of any service; ii) no service receives more resources than its need [17, 16].

Proposition III.3

The optimal solution to the problem (22)-(24) (i.e., without considering utility limit) is an ME of the proposed resource allocation problem for services with finite demands. However, this solution may lead to a wasteful and non-Pareto optimal allocation.

Proof. Let () be an optimal solution to (22)-(24) and is the dual variable associated with the capacity constraint (24). From Corollary III.2, () is an ME of our model for services with infinite demands. We will show () is also an ME of our model for services with finite demands.

According to Definition II.1, at prices , maximizes , , under the service’s budget constraint. For services with utility limits (i.e., finite demands), since maximizes at prices , also maximizes at while respecting the budget constraint. Additionally, () still satisfies the market clearing condition. Therefore, () is an exact ME of the proposed problem for services with finite demands.

However, can be a wasteful allocation since some services with limited utilities may get redundant resources at the equilibrium (i.e., ). These resources can be reallocated to other services that have not reached utility limit to improve their utilities. Thus, may not be Pareto-optimal since some service can get strictly better utility without affecting the utility of other services. This issue is illustrated in the simulation (e.g., see Fig. 2).

In addition to the result presented in Fig. 2 in the simulation, interested readers can refer to Appendix F and Appendix G for some toy examples of the wasteful equilibrium allocation phenomenon. Since multiple market equilibria can exist, we need to impose some criteria to select a good ME. First, we are interested in finding a non-wasteful ME, which implies the equilibrium allocation is efficient. Assume is a non-wasteful allocation and is a non-wasteful ME. The market clearing condition of an ME ensures that no resources desired by any service are left unallocated. Specifically, resources that are not fully allocated have zero prices. As explained in the paragraph following the Definition 2.1, these resources can be given to any service without increasing the utility of the service. Thus, an ME always satisfies the first requirement of a non-wasteful allocation (defined before Proposition 3.3). To satisfy the second requirement that no service receives resources that it has no use for, i.e., we need:


Additionally, resources allocated to a service from an FN must be proportional to the service’s base demand vector (i.e., for all and some constant ).

The second criterion is frugality. It is natural to assume that the services want to maximize their utilities while spending as least money as possible. Hence, a service would prefer an FN with the cheapest price for its base demand vector. Let be the resource prices. The price for the base demand vector of service at FN is


Define . The frugality property states that service will buy resources only from the set of FNs such that . We also define as maximum bang-per-buck (MBB) of service , which generalizes the notion of MBB for linear utility in [9].

Before presenting our main result, it is necessary to understand the buying strategy (i.e., action) of the services at a non-wasteful and frugal ME (. Consider service . To maximize its utility as well as to satisfy the frugality condition, service will buy resources from the cheapest FNs only (i.e., the FNs offer it MBB). In other words, service buys resources only from the set of FNs such that . Furthermore, service either spends full budget to buy resources from the cheapest FNs or spends money until reaching its utility limit. Intuitively, this buying strategy maximizes the utility of the service and satisfies the frugality condition.

Our main finding is that the following optimization problem, which is a natural extension of the EG program, allows us to find a non-wasteful and frugal ME.

subject to (31)

While the idea of adding utility limit constraints is natural, the following theorem and its proof are not trivial since the existing results on ME in the Fisher market (and the GE theory in general) rely heavily on the critical assumptions of non-satiated utility functions [15, 5], which is not the case in our model. Furthermore, the non-wastefulness and frugality notions do not exist in the traditional Fisher model. Theorem III.4 includes two main parts. The first part states that the optimal solutions to the problem (27)-(31) are non-wasteful and frugal market equilibria of our problem. More importantly, the second part states that the set of all the non-wasteful and frugal market equilibria are exactly the set of optimal solutions to the problem (27)-(31).

Based on the analysis of the optimal buying strategy of the services, to prove the first part, we need to show: i) the optimal solutions to (27)-(31) satisfy the market-clearing condition in Definition II.1; ii) the services buy resources from the cheapest FNs only (i.e., FNs offer them MBB); iii) every service either reaches its utility limit or spends full budget. Note that constraints (31)-(31) imply that any optimal solution to this problem is a non-wasteful allocation. To prove the second part of the theorem, we need to show that from the conditions of an ME, non-wastefulness, and frugality, we can reconstruct the problem (27)-(31).

Theorem III.4

The optimal solutions to the problem (27)-(31) are exactly non-wasteful and frugal market equilibria. At the equilibra, every service either spends all budget or attains its utility limit. The ME always exists and the utilities are unique across all such equilibria. Finally, all non-wasteful and frugal market equilibria are captured by the problem (27)-(31).

Proof. Please refer to Appendix -B.

To understand the importance and impact of non-wastefulness and frugality as well as utility limit, we have several remarks as follows.

Remark 1: we again emphasize that from Proposition 3.3, it seems to be natural to add the utility limit constraint to achieve non-wasteful ME. Hence, one may think that “every non-wasteful ME is an optimal solution to the problem (27)-(31).” However, this statement may not hold. A non-wasteful ME may not necessarily be a solution to (27)-(31). In other words, this convex program may not necessarily capture the set of all non-wasteful market equilibria. Indeed, you can observe that the proof of Theorem 3.4 relies heavily on the frugality property.

Remark 2: For a system with one FN only (i.e., buyers with Leontief utility functions), we may not need the frugality criteria since a buyer has only one node to buy resources (i.e., goods) from. The non-wasteful properties may be sufficient since it enforces every buyer to either fully exhaust his budget or reach his utility limit. However, when there are multiple FNs (i.e., the hybrid linear-Leontief utility function in our model), at the equilibrium prices (or any price vector), a buyer who can reach his utility limit may have multiple options to buy resources. Note that in the Fisher market, money has no intrinsic value to the buyers. Hence, he may not need to buy resources from the cheapest FNs to obtain his utility limit. Therefore, frugality is important for our result. Note that if a buyer does not fully spend his budget, the surplus budget can be accumulated/redistributed into later time slots to give more priority to him in the later slots. The detailed policy and implementation are flexible and not the focus of this work. Our work focuses on one time slot only when the system parameters (e.g., budget, limit, preferences, capacities) are given.

Remark 3: Without utility limit, obviously, every buyer will spend full budget to buy more resources to improve his utility. Consequently, every ME is non-wasteful. However, it is not true when we consider utility limit. As shown in the theorem above, some buyers do not fully exhaust their budgets at the equilibrium.

Remark 4: As shown in Proposition 3.1., without utility limit, every ME is an optimal solution to the EG program [5]. Furthermore, the utilities of each buyer at such equilibria are unique [5]. However, when we consider utility limit, there can exist multiple market equilibria. The utilities of each buyer at the equilibria may not be unique (e.g., wasteful ME in Proposition 3.3 and non-wasteful ME in Theorem 3.4). It is also worth noting that there can be other market equilibria which are not the optimal solutions to either the problem (22)-(24) or the problem (27)-(31).

Based on the proof above, we can further show that the market equilibria obtained from (27)-(31) are Pareto-optimal. An allocation is Pareto-optimal if there is no other allocation that would make some service better off without making some other service worse off [4], which means there is no strictly “better” allocation. It is worth noting that the famous first fundamental theorem of welfare economics [8, 4] states that under some mild conditions, an ME is always Pareto-optimal. However, its proof relies on the crucial assumption of locally non-satiated utility functions (e.g., see Proposition 16.C.1 in [4]). Without considering the utility limit, the service utilities become locally non-satiated, hence, every ME is Pareto-efficient. However, due to the utility limit, the utility functions in our problem are locally satiated. Hence, not every equilibrium allocation in our model is Pareto-optimal (e.g., the equilibria mentioned in Proposition 3.3. Therefore, our result on Pareto-optimality is interesting since the utility functions in our problem are locally satiated due to the utility limit.

Lemma III.5

The market equilibria obtained from the problem (27)-(31) are Pareto-optimal.

Proof. We show this by contradiction. Let be an optimal solution to (27)-(31). Assume is a strictly better allocation than . Hence, and strict inequality holds for some . Let be the index of the service that has strictly better utility at . Obviously, if service reaches its utility limit at , it cannot strictly increase its utility. Hence, at , service has not reached its utility limit. Thus, from the results of Theorem III.4, service spends full budget at . Furthermore, we proved that every service buys resources only from cheapest FNs. Hence, at prices , service cannot improve its utility and is Pareto-optimal.

In summary, a non-wasteful and frugal ME is an optimal solution to (27)-(31). Since this is a convex optimization problem, efficient techniques such as the interior-point method can be used to solve it effectively [13, 51]. The computational aspect of this convex program is further discussed in Appendix E.

Iii-C Fairness Properties of the ME

In this section, we show that the proposed ME, which is an optimal solution to (27)-(31), possesses appealing fairness properties that encourage the services to participate in the proposed scheme. An allocation is envy-free if no service envies with the allocation of any other service (i.e., if every service weakly prefers its allocation to the allocation of any other service). In other words, every service is happy with its allocation and does not want to swap its allocation with that of another service. When the budgets are equal, an envy-free allocation implies , [18]. It is well-known that every competitive equilibrium from equal income (CEEI) is envy-free [52]. For the Fisher market, equal income means the buyers have equal budgets. If the budgets are not equal, it is easy to see that a market equilibrium can be not envy-free (e.g., two agents with the same utility function and one good, the agent with lower budget may envy with the allocation of the agent with higher budget). It is because different budgets results in different sets of affordable resource bundles of different agents at the equilibrium prices. Since the services may have different budgets, we need to extend the classical definition of envy-freeness. An allocation is envy-free if , .

Sharing-incentive is another popular fairness criterion. An allocation satisfies this property if it gives every service a better utility than its utility in the proportional sharing scheme. Proportional sharing is an intuitive way to share resources fairly (in terms of resource quantity), which allocates every resource to the services proportional to their budgets. Let be the allocation in which every service receives resources from the FNs proportional to its budget, i.e., , . Indeed, can be interpreted as a resource-fair allocation. The sharing-incentive property implies Additionally, in the fog federation setting where each service contributes a portion of every resource to FN in a resource pool that consists of all the FNs, sharing-incentive ensures that every service prefers the equilibrium allocation to its initial resources contributed to the pool. This property can be interpreted as resource-fairness.

Finally, proportionality is a well-known fairness notion in Economics [18]. Let be the set of all the fog resources. Obviously, is the maximum utility that service can achieve by being allocated all the available resources (i.e., ). It is natural for service to expect to obtain a utility of at least . The proportionality property guarantees that the utility of every service at the equilibrium is at least proportional to its budget. In other words, an allocation satisfies proportionality if Thus, this property can be interpreted as the utility-fairness (i.e., every service feels fair in terms of the achieved utility).

Theorem III.6

The proposed ME is envy-free, and satisfies the sharing-incentive and proportionality properties.

Proof. Please refer to Appendix -C.

Iv Decentralized Solution

In this section, we develop a privacy-preserving distributed algorithm for computing a non-wasteful and frugal ME that is an optimal solution to the problem (27)-(31). The developed algorithm converges to the ME while preserving the services’ privacy. Specifically, no service needs to reveal any private information to other parties including the other services and the platform, which would significantly mitigate the strategic behavior of the market participants. For example, if a service can learn private information of some other services, it may be able to guess the utility functions of these services and submit strategic bids to the platform to gain benefits. Our scheme prevents this issue. The proposed scheme is also robust to common attacks such as collusion and eavesdropping.

We assume that all the services are semi-honest, often called honest-but-curious, which is a common security model in security, privacy, and cryptography research [24, 23]. In the honest-but-curious setting, all parties follow the protocol (i.e., the distributed algorithm) honestly, but they are still curious about the information of other parties. To achieve the design goal of the privacy-preserving distributed algorithm, we first convert (27)-(31) to a standard ADMM form such that the distributed algorithm can be conducted in parallel by the services. This algorithm requires only the average of the optimal demand vectors of the services at each iteration. Thus, our task is to derive an effective procedure for calculating the exact average vector in a privacy-preserving manner.

It is worth noting that if there is only one FN (i.e., a small DC), the ME can be found in a distributed manner using the dual decomposition method [13]. Since the objective function in the problem (27)-(31) is not strictly concave in , we leverage the ADMM technique, which works for non-strictly convex functions. Due to space limitation, here we do not study the single FN case.

First, we rewrite the problem (27)-(31) as follows:

subject to

The traditional ADMM approach [25] cannot be directly applied to tackle this problem since it can only solve optimization problems without inequality constraints. More importantly, the problem (32) has multi-block variables (i.e., ’s) while the traditional ADMM approach can only solve problems with two blocks of variables. An intuitive solution is to extend the traditional ADMM to multi-block variables and update sequentially. However, such Gauss-Seidel ADMM may not converge for [26]. Furthermore, in the traditional ADMM, the blocks are updated one after another, hence, it is not amenable for parallelization. Another solution is to convert the multi-block problem into an equivalent two-block problem via variable splitting [25]. However, this method substantially increases the number of variables and constraints in the problem, especially when is large. In [27], the authors propose the Jacobi-Proximal ADMM approach, which is suitable for parallel and distributed optimization, by adding additional proximal terms to the variable-update step. Our approach does not utilize proximal terms. Finally, the existing approaches require the agents to share their private information with each other in every iteration. Thus, they are not suitable for our design goal.

To make use of ADMM, we first clone all variables ’s using auxiliary variables and obtain the following problem that is equivalent to the problem (32).

subject to

To convert this problem into ADMM form, we define:

where and are indicator functions. Then, the problem (33) can be written in ADMM form as follows:

subject to

with variables , To simplify the notation, we consider each resource type at FN as an item and we have a total of K = M x R items. Then, , , and the problem (34) can be expressed as below.

subject to (36)

We have eliminated the coupling constraints between variables ’s. Furthermore, the variables now can be divided into two blocks (i.e., one contains all ’s, and the other contains all ’s). Hence, we are ready to use the ADMM approach to construct a parallel and distributed algorithm for computing the ME. First, define as follows


Also, let be the dual variables associated with constraint (36). Indeed, we can show that (see Appendix -D). The ADMM-based decentralized implementation is summarized in Algorithm 1. Due to the space limitation, we do not present the construction of this algorithm. Please refer to Appendix -D for the detailed derivation.

In this algorithm, and are the primal and dual residuals at iteration , respectively. As defined in [25], we have and . At each iteration , given and price signal , each service solves a convex optimization problem to find its optimal resource bundle and sends it to the platform. After collecting the optimal demands of all the services, the platform updates by solving (38). Based on the updated values of and , the resource prices can be updated by the platform or the FNs. The algorithm terminates when the primal and dual residuals are sufficiently small [25] or the number of iterations becomes sufficiently large. Otherwise, the new values of and are sent to every service. The steps described above repeat until the algorithm converges. The convergence properties of Algorithm 1 follows directly the standard ADMM method [25].

Remark: It is worth noting that the z-update and dual-update steps can be carried out by every service and the services only need to exchange messages to update . By this way, the algorithm can be implemented in a fully distributed manner by the services (i.e., without the platform).

1:  Initialization: set , , , , , , t = 0.
2:  repeat
3:      At iteration , do:
4:      x-update: each service solves the following sub-problem to compute
5:      z-update: to compute , the platform solves
6:      Dual update: the platform or FNs updates
7:  until  and ) or is too large.
8:  Output: equilibrium allocation and equilibrium prices .
Algorithm 1 Distributed Implementation

Now we consider the privacy-preserving issue. It can be observed that in Algorithm 1, the utility function of a service is only known to that service. However, is required for the z-update step. A conventional approach to obtain is to ask every the services to report to the platform and . However, this approach reveals , which is undesirable. For instance, by learning a sequence of , which is the optimal resource bundle of service given the price signal , an attacker (e.g., the platform or another service) may be able to guess the utility function of service . A privacy-preserving protocol should not disclose any private information of the services. If we can find a method to obtain without asking the exact value of from every service , we can turn Algorithm 1 into a privacy-preserving distributed algorithm. This procedure is executed right before the z-update step and does not affect the properties (e.g., convergence rate) of the ADMM-based distributed algorithm.

Conventional cryptographic techniques for average computation are quite sophisticated [23, 28, 24]. On the other hands, differential privacy approaches do not produce the exact average value [29]. Recently, [30] proposes a novel privacy-preserving average consensus method. This method runs in an iterative manner to find the average value, thus, may not be suitable for our iterative optimization problem. Here, we introduce a simple and efficient technique for privacy-preserving average computation. Specifically, after the x-update step, each service holds a vector . The iteration index is removed for simplicity. We need to compute the average vector while keeping each vector known to service only. The proposed privacy-preserving average computation algorithm works as follows. First, each service selects a random set of other services. Then, it generates a set of random numbers which includes and , for all , such that sum of these numbers is zero, i.e., . Also, , .

Each service keeps and sends to the corresponding service in . To enhance security, the message containing between service and can be encrypted to prevent attackers from eavesdropping. In the next step, each service waits to receive all the messages from the other services who selected . If the message sent from service to service is encrypted, service has to decrypt the message using the shared key between them to extract . Then, service computes and sends the resulting vector to the platform. Obviously, service can also encrypt before sending it the platform. It can be observed that

Thus, the platform can take the average of all the vectors ’s that it receives, which is precisely . The steps above are summarized in Algorithm 2, which allows us to find the exact average vector without disclosing . It is worth noting that the generated noises , , cannot be reused. In other words, we need to rerun the privacy-preserving average computation algorithm at every iteration in Algorithm 1 to prevent an attacker to learn , which is private information of service . In particular, if the attack can overhear information, she can infer Finally, for the fully distributed version of Algorithm 1 (i.e, without the platform), Algorithm 2 can be slightly modified by selecting a service to act as the platform to compute . Then, this service will broadcast the to the other services.

Algorithm 2 is resistant to eavesdropping and collusion attacks. Specifically, the private data of a service (e.g., service ) might be exposed in two situations: i) attackers can eavesdrop on the communication channels between this service and some other services; ii) a group of services (may include the platform) collude to infer . Indeed, the collusion case is equivalent to the case where the communication channels among service and the collusive agents are eavesdropped. Let be the set of services that sends noise signals , , to service . Define , as the set of services that communicate with service .

1:  Input: N services. Each service keeps a vector .
2:  Step 1: each service picks randomly a set of other services.
3:  Step 2: each service locally generates random numbers including and , , such that . For every service , Also, service keeps for herself.
4:  Step 3: each service sends to service and does not send anything to any service .
5:  Step 4: after receiving all from other services, service computes and sends to the platform.
6:  Step 5: the platform computes .
7:  Output: The average vector
Algorithm 2 Privacy-Preserving Averaging

Observe that is the only message of service that contains vector . However, even if an attacker can overhear and decrypt this message to obtain , it is still difficult for her to infer . To recover , the attacker needs to know and . Note that depends on . Thus, is revealed only if all the communication channels between service and the platform as well as the services in are compromised. Define

as the probability that the communication channel between service

and another service (or the platform) is cracked. Let be the probability that the number of services in set is . Then, given , the probability that is disclosed can be approximated by