A Strategy-proof Pricing Scheme for Multiple Resource Type Allocations
∗
Yong Meng Teo and Marian Mihailescu
Department of Computer Science
National University of Singapore
Computing 1, 13 Computing Drive, Singapore 117417
[teoym,marianmi]@comp.nus.edu.sg
Abstract
Resource sharing on the Internet is becoming increasingly
pervasive. Recently, there is growing interest in distributed sys-
tems such as peer-to-peer and grid, with efforts being directed
towards resource allocation strategies that incentivize users to
share resources. While combinatorial auctions can perform
multiple resource type allocations, it is computationally a NP-
complete problem. Thus, allocation in large distributed resource
sharing systems focuses mainly on a single resource type. We
propose a strategy-proof, VCG-based resource pricing scheme
for resource allocation in dynamic markets where users behave
rationally in meeting their own interest. Our mechanism is de-
signed to meet the needs of large distributed systems, deliver-
ing the following key properties: multiple resource type allo-
cations, individual rationality, incentive compatibility for both
buyers and sellers, budget balance and computational efficiency.
Simulation evaluation of our prototype based on a centralized
implementation demonstrates the viability of our approach, as
compared to both traditional and combinatorial auctions.
1 Introduction
Currently, there is growing interest in large scale resource
sharing [5]. In computational grids, users may contribute and
consume resources from a large pool of shared resources. Peer-
to-peer technologies are used increasingly in applications rang-
ing from file-sharing and computational networks to VOIP and
Internet messaging. Users of such systems share their resources
such as compute cycles, files, and bandwidth, while benefiting
from the services provided by the network. Classified as ratio-
nal users, their objective is to maximize their own interest while
participating in the system [17].
Previous allocation techniques, such as those based on Pro-
portional Share [4, 19, 21], do not provide incentives for rational
users to be truthful about their preferences, and result in poor ef-
ficiency by maximizing individual user welfare at the expense of
low overall welfare. Traditionally, agent-based approaches have
been used in distributed systems where different entities have in-
dependent aims and objectives. Mechanism design [5] provides
the designers of such systems the tools needed to incentivize ra-
∗
This is a revised version of the paper published in the Proceedings of 38th
International Conference on Parallel Processing, pp. 172-179, IEEE Computer
Society Press, Vienna, Austria, September 22-25, 2009.
tional agents to act in particular ways in order to achieve the
desired level of “social welfare”. Increasingly, peer-to-peer sys-
tems, mobile computing, e-commerce and grid computing de-
velop into such multi-agent systems where each entity tries to
maximize its own benefit [5, 17]. Recent resource allocation
systems attempt to address the problem of selfish users using
rational agents and mechanism design. These solutions exploit
economic objectives and mechanism design in order to achieve
performance and strategy-proof, using a market-based approach
where agents pay for resource usage with some common virtual
currency. However, it has been shown that no budget-balanced
system that provides incentives can maximize the overall welfare
[10].
In this paper, we investigate how mechanism design and com-
putational economies can be used to create a pricing scheme for
strategy-proof resource allocation, both fast and efficient in the
context of large distributed systems where an agent can both pro-
vide and consume resources of more than one type. Our pricing
scheme is expressed in a virtual economy as a mechanism that
provides incentives for truthful agents.
The main contributions of our paper are: i) formulation of the
resource allocation problem with rational agents in an economic
context, such that mechanism design can be applied, and ii) the
design of a resource pricing scheme for multiple resource type
allocations with provable properties, such as individual rational-
ity, incentive compatibility for both buyer and seller agents, and
budget balance. We perform simulation evaluation for the pro-
posed resource pricing algorithm and compare it with traditional
one-sided and combinatorial auctions.
The remainder of the paper is organized as follows. Section 2
introduces mechanism design and defines key desired properties
in resource allocation. Our proposed pricing scheme is discussed
in Section 3 and a comparative evaluation analysis based on sim-
ulation in Section 4. Section 5 presents a summary of related
work, and Section 6 concludes this paper.
2 Preliminaries
A market refers to the environment, expressed in terms of
rules and mechanisms, where resources within an economy are
exchanged. Different markets may employ distinct mechanisms
for setting the prices of the traded resources. For example, in a
barter economy, resources and services are exchanged directly,
based on the exchange value, without a monetary system.
1
The allocation with the best economic efficiency, also called
Pareto-optimal, is achieved when, given an allocation, no Pareto
improvement can be performed [6]. Given a set of alternative al-
locations, a Pareto improvement is a shift from one allocation to
another that can make at least one individual better off, without
making any other individual worse off. Informally, best eco-
nomic efficiency is achieved when social welfare is maximized.
The social welfare is derived as the total welfare of all agents in
the market.
The concept of economic efficiency is different from the en-
gineering approach commonly used in computer science. Thus,
we use computational efficiency to indicate the algorithm com-
plexity of our pricing mechanism.
2.1 Mechanism Design
We use mechanism design [12] as a framework to create an in-
centive compatible pricing scheme for resource allocation. This
section provides an overview of essential concepts in mechanism
design and introduces the notations used in our proofs.
Given a set of n agents, each with private information t
i
∈
T
i
(e.g. reserved price, number of resource type, etc.), a social
choice function f is defined as:
f : T
1
× . . . × T
n
→ O
where O is a set of possible outcomes (e.g. allocation results).
A mechanism M is represented by the tuple (f, p
1
, . . . , p
n
),
where p
i
is the payment received from agent i when the social
choice is f . Agent’s i valuation for a particular outcome o is
denoted by v
i
(t
i
, o(t
d
i
, t
d
−i
)), where t
d
i
is the declared informa-
tion of agent i, as opposed to t
i
which is the private (reserved)
information. Similarly, t
d
−i
is the declared private information of
all other agents. Agent utility or welfare is measured using the
function:
u
i
(t
i
, t
d
i
, t
d
−i
) = v
i
(t
i
, o(t
d
i
, t
d
−i
)) + p
i
(t
d
i
, t
d
−i
)
The objective of a mechanism is to choose a desirable out-
come o and a set of payments p
i
. The criteria used to choose the
outcome is defined by some desirable properties of that mecha-
nism. In the following, we define four desirable properties for a
resource allocation mechanism.
Definition 1 (Individual Rationality - IR). In an individual-
rational mechanism, rational agents gain higher utility from ac-
tively participating in the mechanism than from avoiding it.
Thus, by ensuring that agents stand to gain from participation,
the mechanism provides incentives for rational agents to get re-
sources and requests into the system.
Definition 2 (Economic Efficiency - PO). The best economic
efficiency, also called Pareto-optimal, is achieved when, given
an allocation, no Pareto improvement can be performed. Given
a set of alternative allocations, a Pareto improvement is a shift
from one allocation to another that can make at least one par-
ticipant better off, without making any other participant worse
off.
A Pareto-optimal resource allocation is achieved when the total
welfare of all agents is maximized. This ensures that resources
are allocated to the agent that values them the most. The social
choice function used to achieve economic efficiency is:
f
P O
(o, t) = max
o
X
i
u
i
Definition 3 (Incentive Compatibility - IC). A mechanism is
incentive compatible if the dominant strategy for each agent
is to reveal its true valuation: u
i
(t
i
, t
d
i
, t
d
−i
) = u
i
(t
i
, t
i
, t
d
−i
).
Thus, agents have no incentives to declare false information, and
t
d
i
= t
i
is a truthful strategy.
A mechanism that is both incentive-compatible and individual
rational is said to be strategy-proof.
Definition 4 (Budget Balance - BB). In a budget balanced
mechanism, the sum of all agent payments is
P
i
p
i
= 0.
Budget balance ensures that allocations do not result in budget
deficit or surplus.
Vickrey, Clarke and Groves (VCG) introduce a class of mech-
anisms that are both economic efficient and strategy-proof [7].
Suitable for any utilitarian design problem, VCG mechanisms
are characterized by the following payment function:
p
i
=
X
j6=i
v
j
(t
j
, o) + h
i
(t
−i
)
where h
i
is an arbitrary function of private information of the
other agents, t
−i
. Informally, VCG mechanisms are incentive
compatible because agent payments are determined indepen-
dently of their declared private information, hence there are no
incentives for a rational agent to declare false information. Fur-
thermore, they are efficient because the payment is a function of
all other agents’ valuations, and individual rational because all
agents’ welfare is positive, and agents involved in an exchange
have welfare greater than 0.
The Myerson-Satterthwaite impossibility theorem [10] is a
well-known result, which verifies that no mechanism can achieve
all four properties at the same time. Indeed, VCG mechanisms
are not budget-balanced [13] and require a third-party agent
(called a market-maker) to mediate between seller and buyer
agents and to provide the surplus or deficit budget. Parkes et al.
[13] argue that budget-balance is possible in a Vickrey-Clarke-
Groves mechanism if payments are implemented on one side of
the exchange, and that side has no aggregation. In resource al-
location, an aggregation involves a bundle containing more than
one resource type.
3 Proposed Pricing Mechanism
Resource allocation is a complex process, which can be di-
vided in several independent steps, such as resource location,
pricing, allocation administration, etc. In this paper, we focus on
the design and evaluation of the pricing mechanism.
Pricing represents the process of computing the economic ex-
change value of resources relative to some common currency.
Thus, we consider a virtual economy in which common currency
provides the basis for a utilitarian function that can be exploited
by our mechanism. This qualifies the common currency to mea-
sure the welfare of market participants, to provide the means for
2
incentives, and to enable the trading of multiple resource types.
Other mechanism design incentive-compatible solutions, such as
network-of-favors or tit-for-tat, are not able to provide a virtual
economy in which resources of different types can be traded.
In a resource market, the process of matching market partici-
pants, e.g. buyers and sellers, to engage in an exchange is called
pricing mechanism. The objective of the pricing mechanism is to
choose an outcome, also known as winner determination, and a
set of payments. The winner determination problem resolves the
agents which participate in an exchange. The payments for that
exchange are facilitated by the use of common currency. Given a
fixed set of alternative choices, with subjectively known distribu-
tions of outcomes for each alternative, a rational agent selects an
alternative to maximize the expected value of his utility function.
In the context of our virtual economy, the goal of the agents is to
maximize the amount of currency they possess in order to secure
resources in the system. Thus, rational agents are incentivized to
share resources in order to gain currency such that their request
benefits from the best possible allocation.
A mechanism design problem consists of an outcome specifi-
cation and a set of agent utilities. The output specification maps
each vector of private information t
1
, . . . t
n
to the set of allowed
outputs, o ∈ O. We formulate the resource allocation problem in
a resource sharing system where users can both share and con-
sume resources as a general mechanism design problem as fol-
lows.
Market-based Resource Allocation Problem
Given a market containing requests submitted by buyers and
resources offered by sellers, each participant is modeled by a
rational agent i with private information t
i
. A seller agent has
private information t
r
s
, the underlying costs for the available re-
source r, such as power consumption, bandwidth costs, etc. The
buyer’s agent private information is t
R
b
, the maximum price the
buyer is willing to pay such that resources are allocated to sat-
isfy its request R. Agent’s i valuation is t
r/R
i
if the resource r
(request R) is allocated, and 0 if not. For a particular request R,
the goal is to allocate resources such that the underlying costs
are minimized.
More formally:
• The possible outputs of the mechanism are all partitions x =
x
1
. . . x
n
of resources that satisfy r, where x
i
is the set of re-
sources that agent i contributes to the allocation.
• The objective function is g(x, t) =
P
|x
i
|>0
P
j∈x
i
t
j
i
.
• Agent’s i valuation is v
i
(x, t
i
) =
P
j∈x
i
t
j
i
.
This is an optimization problem, since the output specifica-
tion is given by a positive real valued objective function, g(x, t),
and the output o minimizes g. Moreover, it is utilitarian since the
objective function satisfies the relation g(o, t) =
P
i
u
i
(t
i
, o).
This allows us to apply a VCG mechanism to our design prob-
lem.
Alongside the seller and buyer agents, we introduce the
market-maker agent, which acts as resource broker to mediate
between sellers and buyers (see Figure 1).
An allocation is determined by a market-maker agent and rep-
resents an exchange between one buyer agent and at least one
[RT_n, #items, t ]
s
d
Resources
Market Maker
Requests
Winner Determination
p
s
p
b
Payments
RT_1, #items
RT_n, #items
s
t [RT_1]
s
t [RT_n]
s
...
...
Resources /
Requests
Private
Information Agent
Declared
Information
...
[RT_1, #items, t ]
s
d
b
t [Req_1]
b
t [Req_m]
b
Req_1
RT_1, #items
RT_n, #items
Req_m
......
...
Req_1
[RT_1, #items,
RT_n, #items, t ]
Req_m [...]
b
d
...
...
Figure 1. Market-based Resource Allocation
seller agent. Payments are made by the buyer agent for the re-
sources allocated to satisfy its request, and received by seller
agents for the resources provided for the allocation.
3.1 Winner Determination for Multiple Re-
source Types
Our scheme is designed for pricing and allocation of multi-
ple resource types in dynamic markets, where buyer and seller
agents may join and leave at any time. In this section, we de-
scribe the buyer request and seller available resource, and our
strategy for selecting winners.
A buyer request consists of one or more resource types and its
associated number of items requested. A simplified request de-
scription shown below include the buyer identifier, each resource
type (RT) with its number of items (#items), and the buying price
(t
Rd
b
):
request[buyer_id, (RT_1, #items) and
... and
(RT_n, #items), price]
Seller agents publish its resources as and when they become
available. A seller agent publishes multiple resource descrip-
tions, one for each resource type. The resource description in-
cludes its identifier, resource type and number of items, and the
price per item (t
rd
s
) :
resource[seller_id, RT, #items, price/item]
Resource descriptions give the market-maker the flexibility to
allocate a number of seller items for each resource type to more
than one buyer and thus maximize resource utilization. We use
t
Rd
b
to denote the buyer’s maximum declared price, as opposed
to t
R
b
which is the private maximum price. Similarly, we use
t
rd
s
for sellers. We consider that the seller’s private price for an
item of a resource type is equal to the underlying costs for that
resource, t
r
s
.
An agent forwards its buy and sell requests to the market-
maker. The buyer requests and seller available resources contain
the declared information (see Figure 1) and represent the input
for our pricing mechanism. Firstly, the market-marker selects a
buyer request and determines the set of successful sellers. Buyer
requests are selected on a First-Come-First-Serve basis to min-
imize agent waiting time. The winning sellers are determined
such that all items of all resource types in the buyer request are
3
allocated and the underlying resource costs are minimized. This
strategy maximizes the overall welfare of sellers. Next, pay-
ments to buyer and sellers are determined using the payment
functions detailed below. Furthermore, we present the proofs
for the properties achieved by our mechanism.
3.2 Seller Payment Function
The payment p
s
for a seller agent s after the allocation of a
request R is determined by the function:
p
s
=
0, if s does not contribute
resources to satisfy R
−c
M|s=∞
+ c
M|s=0
if s contributes
resources to satisfy R
(1)
where:
c
M|s=∞
is the lowest cost to satisfy R without the contribution
of agent s;
c
M|s=0
is the lowest cost to satisfy R when the cost of agent’s s
resources is 0.
We can see that the above function is a VCG payment for seller
agents, since c
M|s=∞
corresponds to h
i
(t
−i
), the arbitrary func-
tion of resource prices of the other agents, and c
M|s=0
corre-
sponds to v
s
(t
s
, o), the valuation of agent s.
3.3 Buyer Payment Function
Given the set S of sellers with resources to satisfy a request
R, the buyer payment function p
b
is:
p
b
= −
X
s∈S
p
s
(2)
3.4 Achieved Properties
Theorem 1. The proposed mechanism is individual rational.
Proof. We consider the allocation of a request R from agent b.
The output of our mechanism is x = x
1
. . . x
n
, where x
i
is the
set of resources that seller i contributes to the allocation. For-
mally, the IR property verifies that u
i
≥ 0 for any winner agent
i. The winner agents in the allocation are: b, the buyer agent,
and S, a set of seller agents such that s ∈ S ⇐⇒ |x
s
| > 0.
When determining the winners, our mechanism chooses the sell-
ers with the lowest underlying costs. Let σ be the winner seller
with the highest underlying costs, and ς the seller with the lowest
underlying costs which is not a winner. Consequently:
v
σ
= max
s∈S
v
s
, v
ς
= min
j /∈S
v
j
; v
σ
≥ v
ς
The payment for seller σ is:
p
σ
= −c
M|σ=∞
+ c
M|σ=0
= −(v
S−σ
+ v
ς
) + v
S−σ
= −v
ς
Thus, the utility of the seller σ is:
u
σ
= v
σ
− v
ς
≥ 0 (3)
Given the buyer payment, p
b
= −
P
s∈S
p
s
, buyer utility is:
u
b
= v
b
−
X
s∈S
p
s
(4)
The market-maker implements our mechanism by solving the
winner determination problem and computing agent payments.
From Equation 3, we see that seller utility is always positive.
In addition, the market-maker implementation verifies that the
result in Equation 4 is positive, to ensure that the utility of the
participating buyer is positive (see Figure 3, line 14).
Theorem 2. The proposed mechanism is budget-balanced.
Proof. It can be seen from Equation 2 that our mechanism uses
the buyer payment function to achieve budget balance. Indeed,
given a buyer request R, and the set of sellers S which provide
resources for R, the sum of all agent payments is:
X
i
p
i
= p
S
+ p
b
=
X
s∈S
p
s
−
X
s∈S
p
s
= 0
Theorem 3. The proposed mechanism is incentive compatible.
Lemma 1. Seller payment function is incentive compatible.
Proof. From Equation 1, we can see that the seller payment
function is based on VCG and is inherently IC, thus we omit
the proof and express the property in Equation 5.
u
s
(t
s
, t
d
s
, t
d
−i
) = u
s
(t
s
, t
s
, t
d
−i
) (5)
Lemma 2. Buyer payment function is incentive compatible.
Proof. From Equation 2, the buyer payment function depends on
the seller agents’ payments p
s
, and is independent of the buyer’s
valuation, v
b
. Seller agent payments depend on the private infor-
mation of other seller agents, t
−s
, and its own valuation for an
outcome, v
s
(t
s
, o). Thus:
p
b
(t
d
b
, t
d
−i
) = p
b
(t
b
, t
s
) = p
b
(t
b
, t
d
−i
) (6)
We require the buyer agents to have the same valuation inde-
pendent of the outcome selected by our pricing mechanism,
v
b
(t
b
, o). This is achieved by selecting buyer requests using a
strategy that is independent of the buyer’s valuation, such as First
Come First Serve. Thus, requests are considered by a market-
maker agent based on the time of their arrival, and not the intrin-
sic value for the buyer agents valuation, such that:
v
b
(t
b
, o(t
d
b
, t
d
−b
)) = v
b
(t
b
, o(t
b
, t
d
−b
)) = v
b
(t
b
, o(t
b
, t
−b
)) (7)
Furthermore, market-maker agents do not take into consideration
the valuation of sellers when computing the payment for a buyer
agent, as long as the condition for IR is satisfied. This allows us
to rewrite the above equation as:
v
b
(t
b
, o(t
d
b
, t
d
−b
)) = v
b
(t
b
, o(t
b
, t
d
−b
)) =
= v
b
(t
b
, o(t
b
, t
−b
)) = v
b
(t
b
, o(t
b
, t
−i
)) (8)
where t
−b
represents the private information of all other buyers,
and t
−i
the private information of all other agents, buyer and
seller.
4
Adding Equation 8 and Equation 6, we obtain the equality:
v
b
(t
b
, o(t
d
b
, t
d
−b
)) + p
b
(t
d
b
, t
d
−i
) = v
b
(t
b
, o(t
b
, t
−i
)) + p
b
(t
b
, t
d
−i
)
which stands for:
u
b
(t
b
, t
d
b
, t
d
−i
) = u
b
(t
b
, t
b
, t
d
−i
) (9)
This relation expresses the IC property of the buyer payment
function.
The results of Lemma 1 and Lemma 2 prove Theorem 3, as
t
d
i
= t
i
.
3.5 Generalized Algorithm and Example
The proposed pricing algorithm is outlined in Figure 3. As-
sume a market consisting of buyer requests and seller available
resources published to a market-maker agent, together with their
reserved prices, t
i
(private information).
Each request is dequeued according to a policy independent
of the buyer’s valuation, such as FCFS (line 3). For each re-
source type (line 4), the market-maker sorts the seller queue for
that resource type based on the reserved price, t
s
(line 5). Next, it
selects the winning sellers from the head of the sorted queue such
that all items in the request may be allocated (lines 6–7), solving
the winner determination problem. Subsequently, we determine
the payments for each seller winner p
s
by computing the two
associated costs, c
M|s=∞
and c
M|s=0
(lines 8–11). Finally, we
compute the buyer payment p
b
(line 13) and inform the winners
of the allocation if their welfare is greater than 0 (lines 14–15).
1 MarketMaker (buyer queue, seller queue)
2 while buyer queue is not empty
3 select next request from the buyer queue (FCFS)
4 for each resource type rt in request
5 sort seller resources of the same type by cost t
s
6 for all items of resource type rt in request
7 determine winning sellers
8 determine c
M |s=0
9 for each winning seller
10 remove seller resources from seller queue
11 determine c
M |s=∞
12 compute winning seller payment p
s
13 compute buyer payment p
b
14 if buyer welfare ≥ 0
15 notify successful sellers and buyer of payments
Figure 3. Generalized Market-Maker Algorithm
For a better understanding of our mechanism, we present a
simple example. Consider a simple market with two resource
types, CPU and disk space, with three sellers and two buyers.
Seller S1 provides one unit of CPU for $1/hour, S2 provides one
CPU at $2/hour and disk space at $2/hour, and S3 provides disk
space for $1/hour. Buyers B1 and B2 both offer to buy one unit
of CPU and disk space for one hour at $5 and $6, respectively
(Figure 2).
Assuming FCFS policy for requests and B1’s request arrives
before B2’s request, B1 is selected by the market-maker first.
We sort the resource list based on the reserved price, and deter-
mine the winners: CPU from S1 and disk space from S3. Table
Agent c
M |s=∞
c
M |s=0
Payment
S1 2 + 1 = 3 0 + 1 = 1 -3 + 1 = -2
S3 1 + 2 = 3 1 + 0 = 1 -3 + 1 = -2
B1 N/A N/A - ( -2 - 2) = 4
Table 1. Proposed Payment Scheme
1 shows the individual payment computation for S1 and S3, to-
gether with B1, the owner of the request.
Using this simple example, we can observe both the prop-
erties achieved by our mechanism, strategy-proof and budget-
balance, and the trade-off in terms of economic efficiency. A
solution that is pareto-optimal, but not budget-balanced, may be
achieved using VCG payments for both buyers and sellers, as
below. First, we compute the total welfare for all possible ex-
changes in Table 2, where winner agents are shown in bold font.
Total Welfare Exchange
w/o S1 6 - 2 - 1 = 3 B2 buys from S2, S3
w/o S2 6 - 1 - 1 = 4 B2 buys from S1, S3
w/o S3 6 - 1 - 2 = 3 B2 buys from S1, S2
w/o B1 6 - 1 - 1 = 4 B2 buys from S1, S3
w/o B2 5 - 1 - 1 = 3 B1 buys from S1, S3
maximum 6 - 1 - 1 = 4 B2 buys from S1, S3
Table 2. Total Welfare and Resource Allocation
Since Pareto-optimal allocation maximizes the sum of agents
utilities, the winners selected in our example are S1, S3 and B2
with the final payments shown in Table 3.
Agent Payment
S1 -1 - (4 - 3) = -2
S3 -1 - (4 - 3) = -2
B2 6 - (4 - 3) = 5
Table 3. Computation of VCG Payments
It is clear that total welfare is greater with VCG payments
than when using our algorithm (B1 buys from S1, S3 vs. B2
buys from S1, S3 in Table 2). However, one thing to note is that
achieving pareto-optimality usually requires an algorithm with
exponential complexity, making the trade-off both in terms of
budget-balance (-2-2+5 yields in $1 deficit in the case of VCG
payments), and computational efficiency.
4 Evaluation
We evaluate the performance of our mechanism using effi-
ciency as a performance measure. Welfare measures the eco-
nomic efficiency and the algorithm runtime represents the com-
putational efficiency. Global efficiency for buyers is defined as
the total number of successful buyer requests, and for sellers as
the average resource utilization of all seller agents, i.e. total re-
sources utilized over total available seller resources.
Using simulation, we first compare our mechanism with tra-
ditional auctions. We evaluate the impact of untruthful users in
a balanced market under different market conditions. Second,
we compare the performance of our mechanism with combina-
torial auctions [9, 11]. For simplicity, we consider a centralized
implementation characterized by a single market-maker agent to
which sellers and buyers submit their requests and available re-
sources.
5