Worst-Case

Optimal

Redistribution

of

VCG

Payments

Mingyu

Guo

Duke

University

Department

of

Computer

Science

Durham,

NC,

USA

mingyu@cs.duke.edu

Vincent

Conitzer

Duke

University

Department

of

Computer

Science

Durham,

NC,

USA

conitzer@cs.duke.edu

ABSTRACT

For

allocation

problems

with

one

or

more

items,

the

wellknown

Vickrey-Clarke-Groves

(VCG)

mechanism

is

efficient,

strategy-proof,

individually

rational,

and

does

not

incur

a

deficit.

However,

the

VCG

mechanism

is

not

(strongly)

budget

balanced:

generally,

the

agents"

payments

will

sum

to

more

than

If

there

is

an

auctioneer

who

is

selling

the

items,

this

may

be

desirable,

because

the

surplus

payment

corresponds

to

revenue

for

the

auctioneer.

However,

if

the

items

do

not

have

an

owner

and

the

agents

are

merely

interested

in

allocating

the

items

efficiently

among

themselves,

any

surplus

payment

is

undesirable,

because

it

will

have

to

flow

out

of

the

system

of

agents.

In

Cavallo

proposed

a

mechanism

that

redistributes

some

of

the

VCG

payment

back

to

the

agents,

while

maintaining

efficiency,

strategy-proofness,

individual

rationality,

and

the

non-deficit

property.

In

this

paper,

we

extend

this

result

in

a

restricted

setting.

We

study

allocation

settings

where

there

are

multiple

indistinguishable

units

of

a

single

good,

and

agents

have

unit

demand.

(For

this

specific

setting,

Cavallo"s

mechanism

coincides

with

a

mechanism

proposed

by

Bailey

in

Here

we

propose

a

family

of

mechanisms

that

redistribute

some

of

the

VCG

payment

back

to

the

agents.

All

mechanisms

in

the

family

are

efficient,

strategyproof,

individually

rational,

and

never

incur

a

deficit.

The

family

includes

the

Bailey-Cavallo

mechanism

as

a

special

case.

We

then

provide

an

optimization

model

for

finding

the

optimal

mechanism-that

is,

the

mechanism

that

maximizes

redistribution

in

the

worst

case-inside

the

family,

and

show

how

to

cast

this

model

as

a

linear

program.

We

give

both

numerical

and

analytical

solutions

of

this

linear

program,

and

the

(unique)

resulting

mechanism

shows

significant

improvement

over

the

Bailey-Cavallo

mechanism

(in

the

worst

case).

Finally,

we

prove

that

the

obtained

mechanism

is

optimal

among

all

anonymous

deterministic

mechanisms

that

satisfy

the

above

properties.

Categories

and

Subject

Descriptors

[Computer

Applications]:

Social

and

Behavioral

Sciences-Economics;

[Distributed

Artificial

Intelligence]:

Multiagent

Systems

General

Terms

Algorithms,

Economics,

Theory

INTRODUCTION

Many

important

problems

in

computer

science

and

electronic

commerce

can

be

modeled

as

resource

allocation

problems.

In

such

problems,

we

want

to

allocate

the

resources

(or

items)

to

the

agents

that

value

them

the

most.

Unfortunately,

agents"

valuations

are

private

knowledge,

and

self-interested

agents

will

lie

about

their

valuations

if

this

is

to

their

benefit.

One

solution

is

to

auction

off

the

items,

possibly

in

a

combinatorial

auction

where

agents

can

bid

on

bundles

of

items.

There

exist

ways

of

determining

the

payments

that

the

agents

make

in

such

an

auction

that

incentivizes

the

agents

to

report

their

true

valuations-that

is,

the

payments

make

the

auction

strategy-proof.

One

very

general

way

of

doing

so

is

to

use

the

VCG

mechanism

(The

VCG

mechanism

is

also

known

as

the

Clarke

mechanism

or,

in

the

specific

context

of

auctions,

the

Generalized

Vickrey

Auction.)

Besides

strategy-proofness,

the

VCG

mechanism

has

several

other

nice

properties

in

the

context

of

resource

allocation

problems.

It

is

efficient:

the

chosen

allocation

always

maximizes

the

sum

of

the

agents"

valuations.

It

is

also

(expost)

individually

rational:

participating

in

the

mechanism

never

makes

an

agent

worse

off

than

not

participating.

Finally,

it

has

a

no-deficit

property:

the

sum

of

the

agents"

payments

is

always

nonnegative.

In

many

settings,

another

property

that

would

be

desirable

is

(strong)

budget

balance,

meaning

that

the

payments

sum

to

exactly

Suppose

the

agents

are

trying

to

distribute

some

resources

among

themselves

that

do

not

have

a

previous

owner.

For

example,

the

agents

may

be

trying

to

allocate

the

right

to

use

a

shared

good

on

a

given

day.

Or,

the

agents

may

be

trying

to

allocate

a

resource

that

they

have

collectively

constructed,

discovered,

or

otherwise

obtained.

If

the

agents

use

an

auction

to

allocate

these

resources,

and

the

sum

of

the

agents"

payments

in

the

auction

is

positive,

then

this

surplus

payment

must

leave

the

system

of

the

agents

(for

example,

the

agents

must

give

the

money

to

an

outside

party,

or

burn

it).

Na¨ıve

redistribution

of

the

surplus

payment

(e.g.

each

of

the

n

agents

receives

of

the

surplus)

will

generally

result

in

a

mechanism

that

is

not

strategy-proof

(e.g.

in

a

Vickrey

auction,

the

second-highest

bidder

would

want

to

increase

her

bid

to

obtain

a

larger

redistribution

payment).

Unfortunately,

the

VCG

mechanism

is

not

budget

balanced:

typically,

there

is

surplus

payment.

Unfortunately,

in

general

settings,

it

is

in

fact

impossible

to

design

mechanisms

that

satisfy

budget

balance

in

addition

to

the

other

desirable

properties

In

light

of

this

impossibility

result,

several

authors

have

obtained

budget

balance

by

sacrificing

some

of

the

other

desirable

properties

Another

approach

that

is

perhaps

preferable

is

to

use

a

mechanism

that

is

more

budget

balanced

than

the

VCG

mechanism,

and

maintains

all

the

other

desirable

properties.

One

way

of

trying

to

design

such

a

mechanism

is

to

redistribute

some

of

the

VCG

payment

back

to

the

agents

in

a

way

that

will

not

affect

the

agents"

incentives

(so

that

strategy-proofness

is

maintained),

and

that

will

maintain

the

other

properties.

In

Cavallo

pursued

exactly

this

idea,

and

designed

a

mechanism

that

redistributes

a

large

amount

of

the

total

VCG

payment

while

maintaining

all

of

the

other

desirable

properties

of

the

VCG

mechanism.

For

example,

in

a

single-item

auction

(where

the

VCG

mechanism

coincides

with

the

second-price

sealed-bid

auction),

the

amount

redistributed

to

bidder

i

by

Cavallo"s

mechanism

is

times

the

second-highest

bid

among

bids

other

than

i"s

bid.

The

total

redistributed

is

at

most

the

second-highest

bid

overall,

and

the

redistribution

to

agent

i

does

not

affect

i"s

incentives

because

it

does

not

depend

on

i"s

own

bid.

In

this

paper,

we

restrict

our

attention

to

a

limited

setting,

and

in

this

setting

we

extend

Cavallo"s

result.

We

study

allocation

settings

where

there

are

multiple

indistinguishable

units

of

a

single

good,

and

all

agents

have

unit

demand,

i.e.

they

want

only

a

single

unit.

For

this

specific

setting,

Cavallo"s

mechanism

coincides

with

a

mechanism

proposed

by

Bailey

in

Here

we

propose

the

family

of

linear

VCG

redistribution

mechanisms.

All

mechanisms

in

this

family

are

efficient,

strategy-proof,

individually

rational,

and

never

incur

a

deficit.

The

family

includes

the

Bailey-Cavallo

mechanism

as

a

special

case

(with

the

caveat

that

we

only

study

allocation

settings

with

multiple

indistinguishable

units

of

a

single

good

and

unit

demand,

while

Bailey"s

and

Cavallo"s

mechanisms

can

be

applied

outside

these

settings

as

well).

We

then

provide

an

optimization

model

for

finding

the

optimal

mechanism

inside

the

family,

based

on

worst-case

analysis.

Both

numerical

and

analytical

solutions

of

this

model

are

provided,

and

the

resulting

mechanism

shows

significant

improvement

over

the

BaileyCavallo

mechanism

(in

the

worst

case).

For

example,

for

the

problem

of

allocating

a

single

unit,

when

the

number

of

agents

is

our

mechanism

always

redistributes

more

than

of

the

total

VCG

payment

back

to

the

agents

(whereas

the

Bailey-Cavallo

mechanism

redistributes

only

in

the

worst

case).

Finally,

we

prove

that

our

mechanism

is

in

fact

optimal

among

all

anonymous

deterministic

mechanisms

(even

nonlinear

ones)

that

satisfy

the

desirable

properties.

Around

the

same

time,

the

same

mechanism

has

been

independently

derived

by

Moulin

Moulin

actually

pursues

a

different

objective

(also

based

on

worst-case

analysis):

whereas

our

objective

is

to

maximize

the

percentage

of

VCG

payments

that

are

redistributed,

Moulin

tries

to

minimize

the

overall

payments

from

agents

as

a

percentage

of

efficiency.

It

turns

out

that

the

resulting

mechanisms

are

the

same.

Towards

the

end

of

this

paper,

we

consider

dropping

the

individual

rationality

requirement,

and

show

that

this

does

not

change

the

optimal

mechanism

for

our

objective.

For

Moulin"s

objective,

dropping

individual

rationality

does

change

the

optimal

mechanism

(but

only

if

there

are

multiple

units).

PROBLEM

DESCRIPTION

Let

n

denote

the

number

of

agents,

and

let

m

denote

the

number

of

units.

We

only

consider

the

case

where

m

n

(otherwise

the

problem

becomes

trivial).

We

also

assume

that

m

and

n

are

always

known.

(This

assumption

is

not

harmful:

in

environments

where

anyone

can

join

the

auction,

running

a

redistribution

mechanism

is

typically

not

a

good

idea

anyway,

because

everyone

would

want

to

join

to

collect

part

of

the

redistribution.)

Let

the

set

of

agents

be

an},

where

ai

is

the

agent

with

ith

highest

report

value

ˆvi-that

is,

we

have

ˆvn

Let

vi

denote

the

true

value

of

ai.

Given

that

the

mechanism

is

strategy-proof,

we

can

assume

vi

ˆvi.

Under

the

VCG

mechanism,

each

agent

among

am

wins

a

unit,

and

pays

for

this

unit.

Thus,

the

total

VCG

payment

equals

When

m

this

is

the

second-price

or

Vickrey

auction.

We

modify

the

mechanism

as

follows.

After

running

the

original

VCG

mechanism,

the

center

returns

to

each

agent

ai

some

amount

zi,

agent

ai"s

redistribution

payment.

We

do

not

allow

zi

to

depend

on

ˆvi;

because

of

this,

ai"s

incentives

are

unaffected

by

this

redistribution

payment,

and

the

mechanism

remains

strategy-proof.

LINEAR

VCG

REDISTRIBUTION

MECHANISMS

We

are

now

ready

to

introduce

the

family

of

linear

VCG

redistribution

mechanisms.

Such

a

mechanism

is

defined

by

a

vector

of

constants

The

amount

that

the

mechanism

returns

to

agent

ai

is

zi

That

is,

an

agent

receives

plus

times

the

highest

bid

other

than

the

agent"s

own

bid,

plus

times

the

second-highest

other

bid,

etc.

The

mechanism

is

strategy-proof,

because

for

all

i,

zi

is

independent

of

ˆvi.

Also,

the

mechanism

is

anonymous.

It

is

helpful

to

see

the

entire

list

of

redistribution

payments:

zi

zn

We

thank

Rakesh

Vohra

for

pointing

us

to

Moulin"s

working

paper.

Not

all

choices

of

the

constants

produce

a

mechanism

that

is

individually

rational,

and

not

all

choices

of

the

constants

produce

a

mechanism

that

never

incurs

a

deficit.

Hence,

to

obtain

these

properties,

we

need

to

place

some

constraints

on

the

constants.

To

satisfy

the

individual

rationality

criterion,

each

agent"s

utility

should

always

be

non-negative.

An

agent

that

does

not

win

a

unit

obtains

a

utility

that

is

equal

to

the

agent"s

redistribution

payment.

An

agent

that

wins

a

unit

obtains

a

utility

that

is

equal

to

the

agent"s

valuation

for

the

unit,

minus

the

VCG

payment

plus

the

agent"s

redistribution

payment.

Consider

agent

an,

the

agent

with

the

lowest

bid.

Since

this

agent

does

not

win

an

item

(m

n),

her

utility

is

just

her

redistribution

payment

zn.

Hence,

for

the

mechanism

to

be

individually

rational,

the

ci

must

be

such

that

zn

is

always

nonnegative.

If

the

ci

have

this

property,

then

it

actually

follows

that

zi

is

nonnegative

for

every

i,

for

the

following

reason.

Suppose

there

exists

some

i

n

and

some

vector

of

bids

ˆvn

such

that

zi

Then,

consider

the

bid

vector

that

results

from

replacing

ˆvj

by

for

all

j

i,

and

letting

ˆvn

If

we

omit

ˆvn

from

this

vector,

the

same

vector

results

that

results

from

omitting

ˆvi

from

the

original

vector.

Therefore,

an"s

redistribution

payment

under

the

new

vector

should

be

the

same

as

ai"s

redistribution

payment

under

the

old

vector-but

this

payment

is

negative.

If

all

redistribution

payments

are

always

nonnegative,

then

the

mechanism

must

be

individually

rational

(because

the

VCG

mechanism

is

individually

rational,

and

the

redistribution

payment

only

increases

an

agent"s

utility).

Therefore,

the

mechanism

is

individually

rational

if

and

only

if

for

any

bid

vector,

zn

To

satisfy

the

non-deficit

criterion,

the

sum

of

the

redistribution

payments

should

be

less

than

or

equal

to

the

total

VCG

payment.

So

for

any

bid

vector

ˆvn

the

constants

ci

should

make

zn

We

define

the

family

of

linear

VCG

redistribution

mechanisms

to

be

the

set

of

all

redistribution

mechanisms

corresponding

to

constants

ci

that

satisfy

the

above

constraints

(so

that

the

mechanisms

will

be

individually

rational

and

have

the

no-deficit

property).

We

now

give

two

examples

of

mechanisms

in

this

family.

Example

(Bailey-Cavallo

mechanism):

Consider

the

mechanism

corresponding

to

m

n

and

ci

for

all

other

i.

Under

this

mechanism,

each

agent

receives

a

redistribution

payment

of

m

n

times

the

highest

bid

from

another

agent.

Hence,

receive

a

redistribution

payment

of

m

n

and

the

others

receive

m

n

Thus,

the

total

redistribution

payment

is

n

+(n−m−

n

This

redistribution

mechanism

is

individually

rational,

because

all

the

redistribution

payments

are

nonnegative,

and

never

incurs

a

deficit,

because

(m

m

n

n

nm

n

(We

note

that

for

this

mechanism

to

make

sense,

we

need

n

m

Example

Consider

the

mechanism

corresponding

to

m

and

ci

for

all

other

i.

In

this

mechanism,

each

agent

receives

a

redistribution

payment

of

m

times

the

(m

highest

reported

value

from

other

agents,

minus

times

the

highest

reported

value

from

other

agents.

Thus,

the

total

redistribution

payment

is

If

n

(which

is

equivalent

to

m

then

each

agent

always

receives

a

nonnegative

redistribution

payment,

thus

the

mechanism

is

individually

rational.

Also,

the

mechanism

never

incurs

a

deficit,

because

the

total

VCG

payment

is

which

is

greater

than

the

amount

that

is

redistributed.

Which

of

these

two

mechanisms

is

better?

Is

there

another

mechanism

that

is

even

better?

This

is

what

we

study

in

the

next

section.

OPTIMAL

REDISTRIBUTION

MECHANISMS

Among

all

linear

VCG

redistribution

mechanisms,

we

would

like

to

be

able

to

identify

the

one

that

redistributes

the

greatest

percentage

of

the

total

VCG

This

is

not

a

well-defined

notion:

it

may

be

that

one

mechanism

redistributes

more

on

some

bid

vectors,

and

another

more

on

other

bid

vectors.

We

emphasize

that

we

do

not

assume

that

a

prior

distribution

over

bidders"

valuations

is

available,

so

we

cannot

compare

them

based

on

expected

redistribution.

Below,

we

study

three

well-defined

ways

of

comparing

redistribution

mechanisms:

best-case

performance,

dominance,

and

worst-case

performance.

Best-case

performance.

One

way

of

evaluating

a

mechanism

is

by

considering

the

highest

redistribution

percentage

that

it

achieves.

Consider

the

previous

two

examples.

For

the

first

example,

the

total

redistribution

payment

is

(m

n

(n

m

n

When

this

is

equal

to

the

total

VCG

payment

Thus,

this

mechanism

redistributes

of

the

total

VCG

payment

in

the

best

case.

For

the

second

example,

the

total

redistribution

payment

is

When

this

is

equal

to

the

total

VCG

payment

Thus,

this

mechanism

also

redistributes

of

the

total

VCG

payment

in

the

best

case.

Moreover,

there

are

actually

infinitely

many

mechanisms

that

redistribute

of

the

total

VCG

payment

in

the

best

case-for

example,

any

convex

combination

of

the

above

two

will

redistribute

if

both

and

Dominance.

Inside

the

family

of

linear

VCG

redistribution

mechanisms,

we

say

one

mechanism

dominates

another

mechanism

if

the

first

one

redistributes

at

least

as

much

as

the

other

for

any

bid

vector.

For

the

previous

two

examples,

neither

dominates

the

other,

because

they

each

redistribute

in

different

cases.

It

turns

out

that

there

is

no

mechanism

in

the

family

that

dominates

all

other

mechanisms

in

the

family.

For

suppose

such

a

mechanism

exists.

Then,

it

should

dominate

both

examples

above.

Consider

the

remaining

VCG

payment

(the

VCG

payment

failed

to

be

redistributed).

The

remaining

VCG

payment

of

the

dominant

mechanism

should

be

whenever

or

Now,

the

remaining

VCG

payment

is

a

linear

function

of

the

ˆvi

(linear

redistribution),

and

therefore

also

a

polynomial

function.

The

above

implies

that

this

function

can

be

written

as

ˆvn),

where

P

is

a

The

percentage

redistributed

seems

the

natural

criterion

to

use,

among

other

things

because

it

is

scale-invariant:

if

we

multiply

all

bids

by

the

same

positive

constant

(for

example,

if

we

change

the

units

by

re-expressing

the

bids

in

euros

instead

of

dollars),

we

would

not

want

the

behavior

of

our

mechanism

to

change.

polynomial

function.

But

since

the

function

must

be

linear

(has

degree

at

most

it

follows

that

P

Thus,

a

dominant

mechanism

would

always

redistribute

all

of

the

VCG

payment,

which

is

not

possible.

(If

it

were

possible,

then

our

worst-case

optimal

redistribution

mechanism

would

also

always

redistribute

all

of

the

VCG

payment,

and

we

will

see

later

that

it

does

not.)

Worst-case

performance.

Finally,

we

can

evaluate

a

mechanism

by

considering

the

lowest

redistribution

percentage

that

it

guarantees.

For

the

first

example,

the

total

redistribution

payment

is

n

n

which

is

greater

than

or

equal

to

m

n

So

in

the

worst

case,

which

is

when

the

percentage

redistributed

is

n

For

the

second

example,

the

total

redistribution

payment

is

which

is

greater

than

or

equal

to

So

in

the

worst

case,

which

is

when

the

percentage

redistributed

is

Since

we

assume

that

the

number

of

agents

n

and

the

number

of

units

m

are

known,

we

can

determine

which

example

mechanism

has

better

worst-case

performance

by

comparing

the

two

quantities.

When

n

and

m

for

the

first

example

(Bailey-Cavallo

mechanism),

the

percentage

redistributed

in

the

worst

case

is

and

for

the

second

example,

this

percentage

is

which

implies

that

for

this

pair

of

n

and

m,

the

first

mechanism

has

better

worst-case

performance.

On

the

other

hand,

when

n

and

m

for

the

first

example,

the

percentage

redistributed

in

the

worst

case

is

and

for

the

second

example,

this

percentage

is

which

implies

that

this

time

the

second

mechanism

has

better

worst-case

performance.

Thus,

it

seems

most

natural

to

compare

mechanisms

by

the

percentage

of

total

VCG

payment

that

they

redistribute

in

the

worst

case.

This

percentage

is

undefined

when

the

total

VCG

payment

is

To

deal

with

this,

technically,

we

define

the

worst-case

redistribution

percentage

as

the

largest

k

so

that

the

total

amount

redistributed

is

at

least

k

times

the

total

VCG

payment,

for

all

bid

vectors.

(Hence,

as

long

as

the

total

amount

redistributed

is

at

least

when

the

total

VCG

payment

is

these

cases

do

not

affect

the

worst-case

percentage.)

This

corresponds

to

the

following

optimization

problem:

Maximize

k

(the

percentage

redistributed

in

the

worst

case)

Subject

to:

For

every

bid

vector

ˆvn

zn

(individual

rationality)

zn

(non-deficit)

zn

(worst-case

constraint)

We

recall

that

zi

TRANSFORMATION

TO

LINEAR

PROGRAMMING

The

optimization

problem

given

in

the

previous

section

can

be

rewritten

as

a

linear

program,

based

on

the

following

observations.

Claim

If

satisfy

both

the

individual

rationality

and

the

non-deficit

constraints,

then

ci

for

i

m.

Proof.

First,

let

us

prove

that

Consider

the

bid

vector

in

which

ˆvi

for

all

i.

To

obtain

individual

rationality,

we

must

have

To

satisfy

the

non-deficit

constraint,

we

must

have

Thus

we

know

Now,

if

ci

for

all

i,

there

is

nothing

to

prove.

Otherwise,

let

j

min{i|ci

Assume

that

j

m.

We

recall

that

we

can

write

the

individual

rationality

constraint

as

follows:

zn

for

any

bid

vector.

Let

us

consider

the

bid

vector

in

which

ˆvi

for

i

j

and

ˆvi

for

the

rest.

In

this

case

zn

cj,

so

we

must

have

cj

The

non-deficit

constraint

can

be

written

as

follows:

zn

for

any

bid

vector.

Consider

the

same

bid

vector

as

above.

We

have

zi

for

i

j,

because

for

these

bids,

the

jth

highest

other

bid

has

value

so

all

the

ci

that

are

nonzero

are

multiplied

by

For

i

j,

we

have

zi

cj,

because

the

jth

highest

other

bid

has

value

and

all

lower

bids

have

value

So

the

non-deficit

constraint

tells

us

that

cj(n

j)

Because

j

m,

so

the

right

hand

side

is

We

also

have

n

j

because

j

m

n.

So

cj

Because

we

have

already

established

that

cj

it

follows

that

cj

but

this

is

contrary

to

assumption.

So

j

m.

Incidentally,

this

claim

also

shows

that

if

m

n

then

ci

for

all

i.

Thus,

we

are

stuck

with

the

VCG

mechanism.

From

here

on,

we

only

consider

the

case

where

m

n

Claim

The

individual

rationality

constraint

can

be

written

as

follows:

Pj

ci

for

j

m

n

Before

proving

this

claim,

we

introduce

the

following

lemma.

Lemma

Given

a

positive

integer

k

and

a

set

of

real

constants

sk,

sktk

for

any

tk

if

and

only

if

Pj

si

for

j

k).

Proof.

Let

di

ti

for

i

and

dk

tk.

Then

.+sktk

for

any

tk

is

equivalent

to

Pk

si)dk

for

any

set

of

arbitrary

non-negative

dj).

When

Pj

si

for

j

k,

the

above

inequality

is

obviously

true.

If

for

some

j,

Pj

si

if

we

set

dj

and

di

for

all

i

j,

then

the

above

inequality

becomes

false.

So

Pj

si

for

j

k

is

both

necessary

and

sufficient.

We

are

now

ready

to

present

the

proof

of

Claim

Proof.

The

individual

rationality

constraint

can

be

written

as

zn

for

any

bid

vector

ˆvn

We

have

already

shown

that

ci

for

i

m.

Thus,

the

above

can

be

simplified

to

zn

for

any

bid

vector.

By

the

above

lemma,

this

is

equivalent

to

Pj

ci

for

j

m

n

Claim

The

non-deficit

constraint

and

the

worst-case

constraint

can

also

be

written

as

linear

inequalities

involving

only

the

ci

and

k.

Proof.

The

non-deficit

constraint

requires

that

for

any

bid

vector,

.+zn

where

zi

for

i

n.

Because

ci

for

i

m,

we

can

simplify

this

inequality

to

qnˆvn

m

(n

m

qi

−(n−i)ci,

for

i

(when

m

n

this

set

of

equalities

is

empty)

qn

−(n

By

the

above

lemma,

this

is

equivalent

to

Pj

qi

for

j

m

n.

So,

we

can

simplify

further

as

follows:

(n

m

m

qm+i

n

cj

(n

m

i)cm+i

m

for

i

n

m

qn

n

cj

m

So,

the

non-deficit

constraint

can

be

written

as

a

set

of

linear

inequalities

involving

only

the

ci.

The

worst-case

constraint

can

be

also

written

as

a

set

of

linear

inequalities,

by

the

following

reasoning.

The

worstcase

constraint

requires

that

for

any

bid

input

zn

where

zi

for

i

n.

Because

ci

for

i

m,

we

can

simplify

this

inequality

to

Qnˆvn

(n

m

km

Qi

(i

(n

i)ci,

for

i

m

n

Qn

(n

By

the

above

lemma,

this

is

equivalent

to

Pj

Qi

for

j

m

n.

So,

we

can

simplify

further

as

follows:

(n

m

km

Qm+i

n

cj

(n

m

i)cm+i

km

for

i

n

m

Qn

n

cj

km

So,

the

worst-case

constraint

can

also

be

written

as

a

set

of

linear

inequalities

involving

only

the

ci

and

k.

Combining

all

the

claims,

we

see

that

the

original

optimization

problem

can

be

transformed

into

the

following

linear

program.

Variables:

k

Maximize

k

(the

percentage

redistributed

in

the

worst

case)

Subject

to:Pj

ci

for

j

m

n

km

(n

m

m

km

n

cj

(n

m

i)cm+i

m

for

i

n

m

km

n

cj

m

NUMERICAL

RESULTS

For

selected

values

of

n

and

m,

we

solved

the

linear

program

using

Glpk

(GNU

Linear

Programming

Kit).

In

the

table

below,

we

present

the

results

for

a

single

unit

(m

We

present

(the

percentage

of

the

total

VCG

payment

that

is

not

redistributed

by

the

worst-case

optimal

mechanism

in

the

worst

case)

instead

of

k

in

the

second

column

because

writing

k

would

require

too

many

significant

digits.

Correspondingly,

the

third

column

displays

the

percentage

Number

of

AgentsWorst−caseRedistributionPercentage

Unit

WO

Unit

BC

Units

WO

Units

BC

Units

WO

Units

BC

Units

WO

Units

BC

Figure

A

comparison

of

the

worst-case

optimal

mechanism

(WO)

and

the

Bailey-Cavallo

mechanism

(BC).

of

the

total

VCG

payment

that

is

not

redistributed

by

the

Bailey-Cavallo

mechanism

in

the

worst

case

(which

is

equal

to

n

n

k

Bailey

Cavallo

Mechanism

The

worst-case

optimal

mechanism

significantly

outperforms

the

Bailey-Cavallo

mechanism

in

the

worst

case.

Perhaps

more

surprisingly,

the

worst-case

optimal

mechanism

sometimes

does

better

in

the

worst

case

than

the

BaileyCavallo

mechanism

does

on

average,

as

the

following

example

shows.

Recall

that

the

total

redistribution

payment

of

the

BaileyCavallo

mechanism

is

(m

n

(n

m

n

For

the

single-unit

case,

this

simplifies

to

n

n

Hence

the

percentage

of

the

total

VCG

payment

that

is

not

redistributed

is

ˆv2−

n

ˆv3−

n

n

n

which

has

an

expected

value

of

E(

n

n

n

n

E

Suppose

the

bid

values

are

drawn

from

a

uniform

distribution

over

The

theory

of

order

statistics

tells

us

that

the

joint

probability

density

function

of

and

is

n(n

for

Now,

E

R

R

So,

the

expected

value

of

the

remaining

percentage

is

n

n

For

n

this

is

whereas

the

remaining

percentage

for

the

worst-case

optimal

mechanism

is

in

the

worst

case.

Let

us

present

the

optimal

solution

for

the

case

n

in

detail.

By

solving

the

above

linear

program,

we

find

that

the

optimal

values

for

the

ci

are

−1

and

That

is,

the

redistribution

payment

received

by

each

agent

is:

times

the

second

highest

bid

among

the

other

agents,

minus

times

the

third

highest

bid

among

the

other

agents,

plus

times

the

fourth

highest

bid

among

the

other

agents.

The

total

amount

redistributed

is

in

the

worst

case,

is

redistributed.

Hence,

the

percentage

of

the

total

VCG

payment

that

is

not

redistributed

is

never

more

than

Finally,

we

compare

the

worst-case

optimal

mechanism

to

the

Bailey-Cavallo

mechanism

for

m

n

m

These

results

are

in

Figure

We

see

that

for

any

m,

when

n

m

the

worst-case

optimal

mechanism

has

the

same

worst-case

performance

as

the

Bailey-Cavallo

mechanism

(actually,

in

this

case,

the

worst-case

optimal

mechanism

is

identical

to

the

BaileyCavallo

mechanism).

When

n

m

the

worst-case

optimal

mechanism

outperforms

the

Bailey-Cavallo

mechanism

(in

the

worst

case).

ANALYTICAL

CHARACTERIZATION

OF

THE

WORST-CASE

OPTIMAL

MECHANISM

We

recall

that

our

linear

program

has

the

following

form:

Variables:

k

Maximize

k

(the

percentage

redistributed

in

the

worst

case)

Subject

to:Pj

ci

for

j

m

n

km

(n

m

m

km

n

cj

(n

m

i)cm+i

m

for

i

n

m

km

n

cj

m

A

linear

program

has

no

solution

if

and

only

if

either

the

objective

is

unbounded,

or

the

constraints

are

contradictory

(there

is

no

feasible

solution).

It

is

easy

to

see

that

k

is

bounded

above

by

(redistributing

more

than

violates

the

non-deficit

constraint).

Also,

a

feasible

solution

always

exists,

for

example,

k

and

ci

for

all

i.

So

an

optimal

solution

always

exists.

Observe

that

the

linear

program

model

depends

only

on

the

number

of

agents

n

and

the

number

of

units

m.

Hence

the

optimal

solution

is

a

function

of

n

and

m.

It

turns

out

that

this

optimal

solution

can

be

analytically

characterized

as

follows.

Theorem

For

any

m

and

n

with

n

the

worstcase

optimal

mechanism

(among

linear

VCG

redistribution

mechanisms)

is

unique.

For

this

mechanism,

the

percentage

redistributed

in

the

worst

case

is

k∗

m

j=m

j

The

worst-case

optimal

mechanism

is

characterized

by

the

following

values

for

the

ci:

c∗

i

(n

m)

i

j=m

j

i

j=i

n

j

for

i

m

n

It

should

be

noted

that

we

have

proved

ci

for

i

m

in

Claim

Proof.

We

first

rewrite

the

linear

program

as

follows.

We

introduce

new

variables

defined

by

xj

Pj

ci

for

j

m

n

The

linear

program

then

becomes:

Variables:

k

Maximize

k

Subject

to:

km

(n

m

m

km

(m

(n

m

i)xm+i

m

for

i

n

m

km

m

xi

for

i

m

m

n

We

will

prove

that

for

any

optimal

solution

to

this

linear

program,

k

k∗

Moreover,

we

will

prove

that

when

k

k∗

xj

Pj

c∗

i

for

j

m

n

This

will

prove

the

theorem.

We

first

make

the

following

observations:

(n

m

(n

m

j=m

j

j

(n

m

j=m

j

j=m

j

m

(n

m

m

(n

m

m

j=m

j

m

k∗

)m

k∗

m

For

i

m

n

ic∗

i

(n

i

i

i

j=m

j

i

j=i

j

(n

i

j=m

j

j

j=m

j

i

j=i

j

(n

i

j=m

j

i

j

j=m

j

k∗

Finally,

(n

(n

j=m

j

j

k∗

Summarizing

the

above,

we

have:

(n

m

k∗

m

(m

(n

m

k∗

(m

(n

m

k∗

(m

(n

m

k∗

(n

k∗

(n

c∗

k∗

(n

k∗

Let

x∗

j

Pj

c∗

i

for

j

m

m

n

the

first

equation

in

the

above

tells

us

that

(n

m

k∗

m.

By

adding

the

first

two

equations,

we

get

(m

(n

m

m

By

adding

the

first

three

equations,

we

get

(m

(n

m

k∗

m

By

adding

the

first

i

equations,

where

i

we

get

(m

i)x∗

(n

m

i)x∗

m+i

m

if

i

is

even

(m

i)x∗

(n

m

i)x∗

m+i

k∗

m

if

i

is

odd

Finally

by

adding

all

the

equations,

we

get

nx∗

m

if

n

m

is

even;

nx∗

k∗

m

if

n

m

is

odd.

Thus,

for

all

of

the

constraints

other

than

the

nonnegativity

constraints,

we

have

shown

that

they

are

satisfied

by

setting

xj

x∗

j

Pj

c∗

i

and

k

k∗

We

next

show

that

the

nonnegativity

constraints

are

satisfied

by

these

settings

as

well.

For

m

i,

i

n

we

have

i

j=i

j

i

i

j=i

j=i

j=i

j

This

implies

that

the

absolute

value

of

c∗

i

is

decreasing

as

i

increases

(if

the

c∗

contains

more

than

one

number).

We

further

observe

that

the

sign

of

c∗

i

alternates,

with

the

first

element

c∗

positive.

So

x∗

j

Pj

c∗

i

for

all

j.

Thus,

we

have

shown

that

these

xi

x∗

i

together

with

k

k∗

form

a

feasible

solution

of

the

linear

program.

We

proceed

to

show

that

it

is

in

fact

the

unique

optimal

solution.

First

we

prove

the

following

claim:

Claim

If

ˆk,

ˆxi,

i

m

m

n

satisfy

the

following

inequalities:

ˆkm

(n

m

m

ˆkm

(m

(n

m

i)ˆxm+i

m

for

i

n

m

ˆkm

m

ˆk

k∗

Then

we

must

have

that

ˆxi

ˆx∗

i

and

ˆk

k∗

Proof

of

claim.

Consider

the

first

inequality.

We

know

that

(n

m

k∗

m,

so

(n

m

ˆkm

k∗

m

(n

m

It

follows

that

x∗

(n

m

Now,

consider

the

next

inequality

for

i

We

know

that

(m

(n

m

m.

It

follows

that

(n

m

so

x∗

(i

n

m

n

m

Now

consider

the

next

inequality

for

i

We

know

that

(m

(n

m

m.

It

follows

that

k∗

(n

m

so

x∗

(i

n

m

n

m

Proceeding

like

this

all

the

way

up

to

i

we

get

that

ˆxm+i

x∗

m+i

if

i

is

odd

and

ˆxm+i

x∗

m+i

if

i

is

even.

Moreover,

if

one

inequality

is

strict,

then

all

subsequent

inequalities

are

strict.

Now,

if

we

can

prove

x∗

it

would

follow

that

the

x∗

i

are

equal

to

the

ˆxi

(which

also

implies

that

ˆk

k∗

We

consider

two

cases:

Case

n

m

is

even.

We

have:

n

m

even

n

m

odd

x∗

We

also

have:

n−m

even

nx∗

m.

Combining

these

two,

we

get

m

nx∗

m

x∗

Case

n

m

is

odd.

In

this

case,

we

have

x∗

and

nx∗

k∗

m.

Then,

we

have:

k∗

m

ˆkm

nx∗

k∗

m

x∗

This

completes

the

proof

of

the

claim.

It

follows

that

if

ˆk,

ˆxi,

i

m

m

n

is

a

feasible

solution

and

ˆk

k∗

then

since

all

the

inequalities

in

Claim

are

satisfied,

we

must

have

ˆxi

x∗

i

and

ˆk

k∗

Hence

no

other

feasible

solution

is

as

good

as

the

one

described

in

the

theorem.

Knowing

the

analytical

characterization

of

the

worst-case

optimal

mechanism

provides

us

with

at

least

two

major

benefits.

First,

using

these

formulas

is

computationally

more

efficient

than

solving

the

linear

program

using

a

generalpurpose

solver.

Second,

we

can

derive

the

following

corollary.

Corollary

If

the

number

of

units

m

is

fixed,

then

as

the

number

of

agents

n

increases,

the

worst-case

percentage

redistributed

linearly

converges

to

with

a

rate

of

convergence

(That

is,

limn→∞

1−k∗

1−k∗

n

That

is,

in

the

limit,

the

percentage

that

is

not

redistributed

halves

for

every

additional

agent.)

We

note

that

this

is

consistent

with

the

experimental

data

for

the

single-unit

case,

where

the

worst-case

remaining

percentage

roughly

halves

each

time

we

add

another

agent.

The

worst-case

percentage

that

is

redistributed

under

the

Bailey-Cavallo

mechanism

also

converges

to

as

the

number

of

agents

goes

to

infinity,

but

the

convergence

is

much

slower-it

does

not

converge

linearly

(that

is,

letting

kC

n

be

the

percentage

redistributed

by

the

Bailey-Cavallo

mechanism

in

the

worst

case

for

n

agents,

limn→∞

n

limn→∞

n

We

now

present

the

proof

of

the

corollary.

Proof.

When

the

number

of

agents

is

n,

the

worst-case

percentage

redistributed

is

k∗

n

m

j=m

j

When

the

number

of

agents

is

n

the

percentage

becomes

k∗

(n

m)

Pn

j=m

(n

j

For

n

sufficiently

large,

we

will

have

and

hence

1−k∗

1−k∗

n

(n

m)

j=m

j

m

Pn

j=m

(n

j

n

n−m

j

(n

j

and

n

n−m

1−k∗

1−k∗

n

n

n−m

(because

`n

j

ni

if

j

i).

Since

we

have

limn→∞

n

n−m

and

limn→∞

n

n−m

it

follows

that

limn→∞

1−k∗

1−k∗

n

WORST-CASE

OPTIMALITY

OUTSIDE

THE

FAMILY

In

this

section,

we

prove

that

the

worst-case

optimal

redistribution

mechanism

among

linear

VCG

redistribution

mechanisms

is

in

fact

optimal

(in

the

worst

case)

among

all

redistribution

mechanisms

that

are

deterministic,

anonymous,

strategy-proof,

efficient

and

satisfy

the

non-deficit

constraint.

Thus,

restricting

our

attention

to

linear

VCG

redistribution

mechanisms

did

not

come

at

a

loss.

To

prove

this

theorem,

we

need

the

following

lemma.

This

lemma

is

not

new:

it

was

informally

stated

by

Cavallo

For

completeness,

we

present

it

here

with

a

detailed

proof.

Lemma

A

VCG

redistribution

mechanism

is

deterministic,

anonymous

and

strategy-proof

if

and

only

if

there

exists

a

function

f

R,

so

that

the

redistribution

payment

zi

received

by

ai

satisfies

zi

ˆvn)

for

all

i

and

all

bid

vectors.

Proof.

First,

let

us

prove

the

only

if

direction,

that

is,

if

a

VCG

redistribution

mechanism

is

deterministic,

anonymous

and

strategy-proof

then

there

exists

a

deterministic

function

f

R,

which

makes

zi

ˆvn)

for

all

i

and

all

bid

vectors.

If

a

VCG

redistribution

mechanism

is

deterministic

and

anonymous,

then

for

any

bid

vector

ˆvn,

the

mechanism

outputs

a

unique

redistribution

payment

list:

zn.

Let

G

Rn

Rn

be

the

function

that

maps

ˆvn

to

zn

for

all

bid

vectors.

Let

H(i,

xn)

be

the

ith

element

of

xn),

so

that

zi

H(i,

ˆvn)

for

all

bid

vectors

and

all

i

n.

Because

the

mechanism

is

anonymous,

two

agents

should

receive

the

same

redistribution

payment

if

their

bids

are

the

same.

So,

if

ˆvi

ˆvj,

H(i,

ˆvn)

H(j,

ˆvn).

Hence,

if

we

let

j

min{t|ˆvt

ˆvi},

then

H(i,

ˆvn)

H(j,

ˆvn).

Let

us

define

K

Rn

N

Rn

as

follows:

K(y,

[j,

wn],

where

wn

are

y,

sorted

in

descending

order,

and

j

min{t|wt

y}.

({t|wt

y}

because

y

wn}).

Also

let

us

define

F

Rn

R

by

F(ˆvi,

ˆvn)

H

K(ˆvi,

ˆvn)

H(min{t|ˆvt

ˆvi},

ˆvn)

H(i,

ˆvn)

zi.

That

is,

F

is

the

redistribution

payment

to

an

agent

that

bids

ˆvi

when

the

other

bids

are

ˆvn.

Since

our

mechanism

is

required

to

be

strategy-proof,

and

the

space

of

valuations

is

unrestricted,

zi

should

be

independent

of

ˆvi

by

Lemma

in

Cavallo

Hence,

we

can

simply

ignore

the

first

variable

input

to

F;

let

So,

we

have

for

all

bid

vectors

and

i,

zi

ˆvn).

This

completes

the

proof

for

the

only

if

direction.

For

the

if

direction,

if

the

redistribution

payment

received

by

ai

satisfies

zi

ˆvn)

for

all

bid

vectors

and

i,

then

this

is

clearly

a

deterministic

and

anonymous

mechanism.

To

prove

strategy-proofness,

we

observe

that

because

an

agent"s

redistribution

payment

is

not

affected

by

her

own

bid,

her

incentives

are

the

same

as

in

the

VCG

mechanism,

which

is

strategy-proof.

Now

we

are

ready

to

introduce

the

next

theorem:

Theorem

For

any

m

and

n

with

n

the

worstcase

optimal

mechanism

among

the

family

of

linear

VCG

redistribution

mechanisms

is

worst-case

optimal

among

all

mechanisms

that

are

deterministic,

anonymous,

strategy-proof,

efficient

and

satisfy

the

non-deficit

constraint.

While

we

needed

individual

rationality

earlier

in

the

paper,

this

theorem

does

not

mention

it,

that

is,

we

can

not

find

a

mechanism

with

better

worst-case

performance

even

if

we

sacrifice

individual

rationality.

(The

worst-case

optimal

linear

VCG

redistribution

mechanism

is

of

course

individually

rational.)

Proof.

Suppose

there

is

a

redistribution

mechanism

(when

the

number

of

units

is

m

and

the

number

of

agents

is

n)

that

satisfies

all

of

the

above

properties

and

has

a

better

worstcase

performance

than

the

worst-case

optimal

linear

VCG

redistribution

mechanism,

that

is,

its

worst-case

redistribution

percentage

ˆk

is

strictly

greater

than

k∗

By

Lemma

for

this

mechanism,

there

is

a

function

f

R

so

that

zi

ˆvn)

for

all

i

and

all

bid

vectors.

We

first

prove

that

f

has

the

following

properties.

Claim

if

the

number

of

is

less

than

or

equal

to

m.

Proof

of

claim.

We

assumed

that

for

this

mechanism,

the

worst-case

redistribution

percentage

satisfies

ˆk

k∗

If

the

total

VCG

payment

is

x,

the

total

redistribution

payment

should

be

in

[ˆkx,

x]

(non-deficit

criterion).

Consider

the

case

where

all

agents

bid

so

that

the

total

VCG

payment

is

also

Hence,

the

total

redistribution

payment

should

be

in

[ˆk

is,

it

should

be

Hence

every

agent"s

redistribution

payment

must

be

Now,

let

ti

where

the

number

of

equals

i.

We

proved

If

consider

the

bid

vector

where

everyone

bids

The

total

VCG

payment

is

m

and

the

total

redistribution

payment

is

This

corresponds

to

redistribution,

which

is

contrary

to

our

assumption

that

ˆk

k∗

Now,

consider

j

min{i|ti

(which

is

well-defined

because

If

j

m,

the

property

is

satisfied.

If

j

m,

consider

the

bid

vector

where

ˆvi

for

i

j

and

ˆvi

for

all

other

i.

Under

this

bid

vector,

the

first

j

agents

each

get

redistribution

payment

and

the

remaining

n

j

agents

each

get

tj.

Thus,

the

total

redistribution

payment

is

(n

j)tj.

Because

the

total

VCG

payment

for

this

bid

vector

is

we

must

have

(n

j)tj

So

tj

(j

m

n).

But

this

is

contrary

to

the

definition

of

j.

Hence

if

the

number

of

is

less

than

or

equal

to

m.

Claim

f

satisfies

the

following

inequalities:

ˆkm

(n

m

m

ˆkm

(m

(n

m

i)tm+i

m

for

i

n

m

ˆkm

m

Here

ti

is

defined

as

in

the

proof

of

Claim

Proof

of

claim.

For

j

m

n,

consider

the

bid

vectors

where

ˆvi

for

i

j

and

ˆvi

for

all

other

i.

These

bid

vectors

together

with

the

non-deficit

constraint

and

worst-case

constraint

produce

the

above

set

of

inequalities:

for

example,

when

j

m

we

consider

the

bid

vector

ˆvi

for

i

m

and

ˆvi

for

all

other

i.

The

first

agents

each

receive

a

redistribution

payment

of

tm

and

all

other

agents

each

receive

Thus,

the

total

VCG

redistribution

is

(n

m

The

nondeficit

constraint

gives

(n

m

m

(because

the

total

VCG

payment

is

m).

The

worst-case

constraint

gives

(n

m

ˆkm.

Combining

these

two,

we

get

the

first

inequality.

The

other

inequalities

can

be

obtained

in

the

same

way.

We

now

observe

that

the

inequalities

in

Claim

together

with

ˆk

k∗

are

the

same

as

those

in

Claim

(where

the

ti

are

replaced

by

the

ˆxi).

Thus,

we

can

conclude

that

ˆk

k∗

which

is

contrary

to

our

assumption

ˆk

k∗

Hence

no

mechanism

satisfying

all

the

listed

properties

has

a

redistribution

percentage

greater

than

k∗

in

the

worst

case.

So

far

we

have

only

talked

about

the

case

where

n

For

the

purpose

of

completeness,

we

provide

the

following

claim

for

the

n

m

case.

Claim

For

any

m

and

n

with

n

m

the

original

VCG

mechanism

(that

is,

redistributing

nothing)

is

(uniquely)

worst-case

optimal

among

all

redistribution

mechanisms

that

are

deterministic,

anonymous,

strategy-proof,

efficient

and

satisfy

the

non-deficit

constraint.

We

recall

that

when

n

Claim

tells

us

that

the

only

mechanism

inside

the

family

of

linear

redistribution

mechanisms

is

the

original

VCG

mechanism,

so

that

this

mechanism

is

automatically

worst-case

optimal

inside

this

family.

However,

to

prove

the

above

claim,

we

need

to

show

that

it

is

worst-case

optimal

among

all

redistribution

mechanisms

that

have

the

desired

properties.

Proof.

Suppose

a

redistribution

mechanism

exists

that

satisfies

all

of

the

above

properties

and

has

a

worst-case

performance

as

good

as

the

original

VCG

mechanism,

that

is,

its

worst-case

redistribution

percentage

is

greater

than

or

equal

to

This

implies

that

the

total

redistribution

payment

of

this

mechanism

is

always

nonnegative.

By

Lemma

for

this

mechanism,

there

is

a

function

f

R

so

that

zi

ˆvn)

for

all

i

and

all

bid

vectors.

We

will

prove

that

for

all

First,

consider

the

bid

vector

where

ˆvi

for

all

i.

Here,

each

agent

receives

a

redistribution

payment

The

total

redistribution

payment

is

then

which

should

be

both

greater

than

or

equal

to

(by

the

above

observation)

as

well

less

than

or

equal

to

(using

the

nondeficit

criterion

and

the

fact

that

the

total

VCG

payment

is

It

follows

that

Now,

let

us

consider

the

bid

vector

where

and

ˆvi

for

all

other

i.

For

this

bid

vector,

the

agent

with

the

highest

bid

receives

a

redistribution

payment

of

and

the

other

n

agents

each

receive

By

the

same

reasoning

as

above,

the

total

redistribution

payment

should

be

both

greater

than

or

equal

to

and

less

than

or

equal

to

hence

for

all

Proceeding

by

induction,

let

us

assume

xk,

for

all

xk

for

some

k

n

Consider

the

bid

vector

where

ˆvi

xi

for

i

k

and

ˆvi

for

all

other

i,

where

the

xi

are

arbitrary

numbers

satisfying

xk

For

the

agents

with

the

highest

k

bids,

their

redistribution

payment

is

specified

by

f

acting

on

an

input

with

only

k

non-zero

variables.

Hence

they

all

receive

by

induction

assumption.

The

other

n

k

agents

each

receive

xk,

The

total

redistribution

payment

is

then

xk,

which

should

be

both

greater

than

or

equal

to

and

less

than

or

equal

to

the

total

VCG

payment.

Now,

in

this

bid

vector,

the

lowest

bid

is

because

k

n.

But

since

n

m

the

total

VCG

payment

is

mˆvn

So

we

have

xk,

for

all

xk

By

induction,

this

statement

holds

for

all

k

n

when

k

n

we

have

for

all

Hence,

in

this

mechanism,

the

redistribution

payment

is

always

that

is,

the

mechanism

is

just

the

original

VCG

mechanism.

Incidentally,

we

obtain

the

following

corollary:

Corollary

No

VCG

redistribution

mechanism

satisfies

all

of

the

following:

determinism,

anonymity,

strategyproofness,

efficiency,

and

(strong)

budget

balance.

This

holds

for

any

n

m

Proof.

For

the

case

n

m

If

such

a

mechanism

exists,

its

worst-case

performance

would

be

better

than

that

of

the

worst-case

optimal

linear

VCG

redistribution

mechanism,

which

by

Theorem

obtains

a

redistribution

percentage

strictly

less

than

But

Theorem

shows

that

it

is

impossible

to

outperform

this

mechanism

in

the

worst

case.

For

the

case

n

m

If

such

a

mechanism

exists,

it

would

perform

as

well

as

the

original

VCG

mechanism

in

the

worst

case,

which

implies

that

it

is

identical

to

the

VCG

mechanism

by

Claim

But

the

VCG

mechanism

is

not

(strongly)

budget

balanced.

CONCLUSIONS

For

allocation

problems

with

one

or

more

items,

the

wellknown

Vickrey-Clarke-Groves

(VCG)

mechanism

is

efficient,

strategy-proof,

individually

rational,

and

does

not

incur

a

deficit.

However,

the

VCG

mechanism

is

not

(strongly)

budget

balanced:

generally,

the

agents"

payments

will

sum

to

more

than

If

there

is

an

auctioneer

who

is

selling

the

items,

this

may

be

desirable,

because

the

surplus

payment

corresponds

to

revenue

for

the

auctioneer.

However,

if

the

items

do

not

have

an

owner

and

the

agents

are

merely

interested

in

allocating

the

items

efficiently

among

themselves,

any

surplus

payment

is

undesirable,

because

it

will

have

to

flow

out

of

the

system

of

agents.

In

Cavallo

proposed

a

mechanism

that

redistributes

some

of

the

VCG

payment

back

to

the

agents,

while

maintaining

efficiency,

strategy-proofness,

individual

rationality,

and

the

non-deficit

property.

In

this

paper,

we

extended

this

result

in

a

restricted

setting.

We

studied

allocation

settings

where

there

are

multiple

indistinguishable

units

of

a

single

good,

and

agents

have

unit

demand.

(For

this

specific

setting,

Cavallo"s

mechanism

coincides

with

a

mechanism

proposed

by

Bailey

in

Here

we

proposed

a

family

of

mechanisms

that

redistribute

some

of

the

VCG

payment

back

to

the

agents.

All

mechanisms

in

the

family

are

efficient,

strategy-proof,

individually

rational,

and

never

incur

a

deficit.

The

family

includes

the

Bailey-Cavallo

mechanism

as

a

special

case.

We

then

provided

an

optimization

model

for

finding

the

optimal

mechanism-that

is,

the

mechanism

that

maximizes

redistribution

in

the

worst

case-inside

the

family,

and

showed

how

to

cast

this

model

as

a

linear

program.

We

gave

both

numerical

and

analytical

solutions

of

this

linear

program,

and

the

(unique)

resulting

mechanism

shows

significant

improvement

over

the

Bailey-Cavallo

mechanism

(in

the

worst

case).

Finally,

we

proved

that

the

obtained

mechanism

is

optimal

among

all

anonymous

deterministic

mechanisms

that

satisfy

the

above

properties.

One

important

direction

for

future

research

is

to

try

to

extend

these

results

beyond

multi-unit

auctions

with

unit

demand.

However,

it

turns

out

that

in

sufficiently

general

settings,

the

worst-case

optimal

redistribution

percentage

is

In

such

settings,

the

worst-case

criterion

provides

no

guidance

in

determining

a

good

redistribution

mechanism

(even

redistributing

nothing

achieves

the

optimal

worst-case

percentage),

so

it

becomes

necessary

to

pursue

other

criteria.

Alternatively,

one

can

try

to

identify

other

special

settings

in

which

positive

redistribution

in

the

worst

case

is

possible.

Another

direction

for

future

research

is

to

consider

whether

this

mechanism

has

applications

to

collusion.

For

example,

in

a

typical

collusive

scheme,

there

is

a

bidding

ring

consisting

of

a

number

of

colluders,

who

submit

only

a

single

bid

If

this

bid

wins,

the

colluders

must

allocate

the

item

amongst

themselves,

perhaps

using

payments-but

of

course

they

do

not

want

payments

to

flow

out

of

the

ring.

This

work

is

part

of

a

growing

literature

on

designing

mechanisms

that

obtain

good

results

in

the

worst

case.

Traditionally,

economists

have

mostly

focused

either

on

designing

mechanisms

that

always

obtain

certain

properties

(such

as

the

VCG

mechanism),

or

on

designing

mechanisms

that

are

optimal

with

respect

to

some

prior

distribution

over

the

agents"

preferences

(such

as

the

Myerson

auction

and

the

Maskin-Riley

auction

for

maximizing

expected

revenue).

Some

more

recent

papers

have

focused

on

designing

mechanisms

for

profit

maximization

using

worst-case

competitive

analysis

(e.g.

There

has

also

been

growing

interest

in

the

design

of

online

mechanisms

where

the

agents

arrive

over

time

and

decisions

must

be

taken

before

all

the

agents

have

arrived.

Such

work

often

also

takes

a

worst-case

competitive

analysis

approach

It

does

not

appear

that

there

are

direct

connections

between

our

work

and

these

other

works

that

focus

on

designing

mechanisms

that

perform

well

in

the

worst

case.

Nevertheless,

it

seems

likely

that

future

research

will

continue

to

investigate

mechanism

design

for

the

worst

case,

and

hopefully

a

coherent

framework

will

emerge.

REFERENCES

G.

Aggarwal,

A.

Fiat,

A.

Goldberg,

J.

Hartline,

N.

Immorlica,

and

M.

Sudan.

Derandomization

of

auctions.

STOC,

M.

J.

Bailey.

The

demand

revealing

process:

to

distribute

the

surplus.

Public

Choice,

R.

Cavallo.

Optimal

decision-making

with

minimal

waste:

Strategyproof

redistribution

of

VCG

payments.

AAMAS,

E.

H.

Clarke.

Multipart

pricing

of

public

goods.

Public

Choice,

B.

Faltings.

A

budget-balanced,

incentive-compatible

scheme

for

social

choice.

AMEC,

J.

Feigenbaum,

C.

Papadimitriou,

and

S.

Shenker.

Sharing

the

cost

of

muliticast

transmissions.

JCSS,

E.

Friedman

and

D.

Parkes.

Pricing

WiFi

at

Starbucks

Issues

in

online

mechanism

design.

EC,

A.

Goldberg,

J.

Hartline,

A.

Karlin,

M.

Saks,

and

A.

Wright.

Competitive

auctions.

Games

and

Economic

Behavior,

A.

Goldberg,

J.

Hartline,

and

A.

Wright.

Competitive

auctions

and

digital

goods.

SODA,

D.

A.

Graham

and

R.

C.

Marshall.

Collusive

bidder

behavior

at

single-object

second-price

and

English

auctions.

Journal

of

Political

Economy,

J.

Green

and

J.-J.

Laffont.

Characterization

of

satisfactory

mechanisms

for

the

revelation

of

preferences

for

public

goods.

Econometrica,

T.

Groves.

Incentives

in

teams.

Econometrica,

M.

T.

Hajiaghayi,

R.

Kleinberg,

M.

Mahdian,

and

D.

C.

Parkes.

Online

auctions

with

re-usable

goods.

EC,

M.

T.

Hajiaghayi,

R.

Kleinberg,

and

D.

C.

Parkes.

Adaptive

limited-supply

online

auctions.

EC,

J.

Hartline

and

R.

McGrew.

From

optimal

limited

to

unlimited

supply

auctions.

EC,

L.

Hurwicz.

On

the

existence

of

allocation

systems

whose

manipulative

Nash

equilibria

are

Pareto

optimal,

Presented

at

the

World

Congress

of

the

Econometric

Society.

K.

Leyton-Brown,

Y.

Shoham,

and

M.

Tennenholtz.

Bidding

clubs

in

first-price

auctions.

AAAI,

E.

Maskin

and

J.

Riley.

Optimal

multi-unit

auctions.

In

F.

Hahn,

editor,

The

Economics

of

Missing

Markets,

Information,

and

Games,

chapter

Clarendon

Press,

Oxford,

H.

Moulin.

Efficient

and

strategy-proof

assignment

with

a

cheap

residual

claimant.

Working

paper,

March

R.

Myerson.

Optimal

auction

design.

Mathematics

of

Operations

Research,

R.

Myerson

and

M.

Satterthwaite.

Efficient

mechanisms

for

bilateral

trading.

Journal

of

Economic

Theory,

D.

Parkes,

J.

Kalagnanam,

and

M.

Eso.

Achieving

budget-balance

with

Vickrey-based

payment

schemes

in

exchanges.

IJCAI,

W.

Vickrey.

Counterspeculation,

auctions,

and

competitive

sealed

tenders.

Journal

of

Finance,

vickrey-clarke-grove
efficient mechanism
strategy-proofness
individually rational mechanism
linear vcg redistribution mechanism
worst-case optimal mechanism
vickrey-clarke-grove mechanism
payment redistribution

mechanism design
redistribution payment
mechanism
transformation to linear programming
analytical characterization


Heuristics-Based

Scheduling

of

Composite

Web

Service

Workloads

Thomas

Phan

Wen-Syan

Li

IBM

Almaden

Research

Center

Harry

Rd.

San

Jose,

CA

{phantom,wsl}@us.ibm.com

ABSTRACT

Web

services

can

be

aggregated

to

create

composite

workflows

that

provide

streamlined

functionality

for

human

users

or

other

systems.

Although

industry

standards

and

recent

research

have

sought

to

define

best

practices

and

to

improve

end-to-end

workflow

composition,

one

area

that

has

not

fully

been

explored

is

the

scheduling

of

a

workflow"s

web

service

requests

to

actual

service

provisioning

in

a

multi-tiered,

multi-organisation

environment.

This

issue

is

relevant

to

modern

business

scenarios

where

business

processes

within

a

workflow

must

complete

within

QoS-defined

limits.

Because

these

business

processes

are

web

service

consumers,

service

requests

must

be

mapped

and

scheduled

across

multiple

web

service

providers,

each

with

its

own

negotiated

service

level

agreement.

In

this

paper

we

provide

heuristics

for

scheduling

service

requests

from

multiple

business

process

workflows

to

web

service

providers

such

that

a

business

value

metric

across

all

workflows

is

maximised.

We

show

that

a

genetic

search

algorithm

is

appropriate

to

perform

this

scheduling,

and

through

experimentation

we

show

that

our

algorithm

scales

well

up

to

a

thousand

workflows

and

produces

better

mappings

than

traditional

approaches.

Categories

and

Subject

Descriptors

[Computer-Communication

Networks]:

Distributed

Systems-distributed

applications;

[Software

Engineering]:

Metrics-complexity

measures,

performance

measures

INTRODUCTION

Web

services

can

be

composed

into

workflows

to

provide

streamlined

end-to-end

functionality

for

human

users

or

other

systems.

Although

previous

research

efforts

have

looked

at

ways

to

intelligently

automate

the

composition

of

web

services

into

workflows

(e.g.

an

important

remaining

problem

is

the

assignment

of

web

service

requests

to

the

underlying

web

service

providers

in

a

multi-tiered

runtime

scenario

within

constraints.

In

this

paper

we

address

this

scheduling

problem

and

examine

means

to

manage

a

large

number

of

business

process

workflows

in

a

scalable

manner.

The

problem

of

scheduling

web

service

requests

to

providers

is

relevant

to

modern

business

domains

that

depend

on

multi-tiered

service

provisioning.

Consider

the

example

shown

in

Figure

that

illustrates

our

problem

space.

Workflows

comprise

multiple

related

business

processes

that

are

web

service

consumers;

here

we

assume

that

the

workflows

represent

requested

service

from

customers

or

automated

systems

and

that

the

workflow

has

already

been

composed

with

an

existing

choreography

toolkit.

These

workflows

are

then

submitted

to

a

portal

(not

shown)

that

acts

as

a

scheduling

agent

between

the

web

service

consumers

and

the

web

service

providers.

In

this

example,

a

workflow

could

represent

the

actions

needed

to

instantiate

a

vacation

itinerary,

where

one

business

process

requests

booking

an

airline

ticket,

another

business

process

requests

a

hotel

room,

and

so

forth.

Each

of

these

requests

target

a

particular

service

type

(e.g.

airline

reservations,

hotel

reservations,

car

reservations,

etc.),

and

for

each

service

type,

there

are

multiple

instances

of

service

providers

that

publish

a

web

service

interface.

An

important

challenge

is

that

the

workflows

must

meet

some

quality-of-service

(QoS)

metric,

such

as

end-to-end

completion

time

of

all

its

business

processes,

and

that

meeting

or

failing

this

goal

results

in

the

assignment

of

a

quantitative

business

value

metric

for

the

workflow;

intuitively,

it

is

desired

that

all

workflows

meet

their

respective

QoS

goals.

We

further

leverage

the

notion

that

QoS

service

agreements

are

generally

agreed-upon

between

the

web

service

providers

and

the

scheduling

agent

such

that

the

providers

advertise

some

level

of

guaranteed

QoS

to

the

scheduler

based

upon

runtime

conditions

such

as

turnaround

time

and

maximum

available

concurrency.

The

resulting

problem

is

then

to

schedule

and

assign

the

business

processes"

requests

for

service

types

to

one

of

the

service

providers

for

that

type.

The

scheduling

must

be

done

such

that

the

aggregate

business

value

across

all

the

workflows

is

maximised.

In

Section

we

state

the

scenario

as

a

combinatorial

problem

and

utilise

a

genetic

search

algorithm

to

find

the

best

assignment

of

web

service

requests

to

providers.

This

approach

converges

towards

an

assignment

that

maximises

the

overall

business

value

for

all

the

workflows.

In

Section

we

show

through

experimentation

that

this

search

heuristic

finds

better

assignments

than

other

algorithms

(greedy,

round-robin,

and

proportional).

Further,

this

approach

allows

us

to

scale

the

number

of

simultaneous

workflows

(up

to

one

thousand

workflows

in

our

experiments)

and

yet

still

find

effective

schedules.

RELATED

WORK

In

the

context

of

service

assignment

and

scheduling,

maps

web

service

calls

to

potential

servers

using

linear

programming,

but

their

work

is

concerned

with

mapping

only

single

workflows;

our

principal

focus

is

on

scalably

scheduling

multiple

workflows

(up

Service

Type

SuperHotels.com

Business

Process

Business

Process

Workflow

Business

Process

Business

Process

HostileHostels.com

IncredibleInns.com

Business

Process

Business

Process

Business

Process

Business

Process

Service

Provider

SkyHighAirlines.com

SuperCrazyFlights.com

Business

Process

Advertised

QoS

Service

Agreement

CarRentalService.com

Figure

An

example

scenario

demonstrating

the

interaction

between

business

processes

in

workflows

and

web

service

providers.

Each

business

process

accesses

a

service

type

and

is

then

mapped

to

a

service

provider

for

that

type.

to

one

thousand

as

we

show

later)

using

different

business

metrics

and

a

search

heuristic.

presents

a

dynamic

provisioning

approach

that

uses

both

predictive

and

reactive

techniques

for

multi-tiered

Internet

application

delivery.

However,

the

provisioning

techniques

do

not

consider

the

challenges

faced

when

there

are

alternative

query

execution

plans

and

replicated

data

sources.

presents

a

feedback-based

scheduling

mechanism

for

multi-tiered

systems

with

back-end

databases,

but

unlike

our

work,

it

assumes

a

tighter

coupling

between

the

various

components

of

the

system.

Our

work

also

builds

upon

prior

scheduling

research.

The

classic

job-shop

scheduling

problem,

shown

to

be

NP-complete

is

similar

to

ours

in

that

tasks

within

a

job

must

be

scheduled

onto

machinery

(c.f.

our

scenario

is

that

business

processes

within

a

workflow

must

be

scheduled

onto

web

service

providers).

The

salient

differences

are

that

the

machines

can

process

only

one

job

at

a

time

(we

assume

servers

can

multi-task

but

with

degraded

performance

and

a

maximum

concurrency

level),

tasks

within

a

job

cannot

simultaneously

run

on

different

machines

(we

assume

business

processes

can

be

assigned

to

any

available

server),

and

the

principal

metric

of

performance

is

the

makespan,

which

is

the

time

for

the

last

task

among

all

the

jobs

to

complete

(and

as

we

show

later,

optimising

on

the

makespan

is

insufficient

for

scheduling

the

business

processes,

necessitating

different

metrics).

DESIGN

In

this

section

we

describe

our

model

and

discuss

how

we

can

find

scheduling

assignments

using

a

genetic

search

algorithm.

Model

We

base

our

model

on

the

simplified

scenario

shown

in

Figure

Specifically,

we

assume

that

users

or

automated

systems

request

the

execution

of

a

workflow.

The

workflows

comprise

business

processes,

each

of

which

makes

one

web

service

invocation

to

a

service

type.

Further,

business

processes

have

an

ordering

in

the

workflow.

The

arrangement

and

execution

of

the

business

processes

and

the

data

flow

between

them

are

all

managed

by

a

composition

or

choreography

tool

(e.g.

Although

composition

languages

can

use

sophisticated

flow-control

mechanisms

such

as

conditional

branches,

for

simplicity

we

assume

the

processes

execute

sequentially

in

a

given

order.

This

scenario

can

be

naturally

extended

to

more

complex

relationships

that

can

be

expressed

in

BPEL

which

defines

how

business

processes

interact,

messages

are

exchanged,

activities

are

ordered,

and

exceptions

are

handled.

Due

to

space

constraints,

we

focus

on

the

problem

space

presented

here

and

will

extend

our

model

to

more

advanced

deployment

scenarios

in

the

future.

Each

workflow

has

a

QoS

requirement

to

complete

within

a

specified

number

of

time

units

(e.g.

on

the

order

of

seconds,

as

detailed

in

the

Experiments

section).

Upon

completion

(or

failure),

the

workflow

is

assigned

a

business

value.

We

extended

this

approach

further

and

considered

different

types

of

workflow

completion

in

order

to

model

differentiated

QoS

levels

that

can

be

applied

by

businesses

(for

example,

to

provide

tiered

customer

service).

We

say

that

a

workflow

is

successful

if

it

completes

within

its

QoS

requirement,

acceptable

if

it

completes

within

a

constant

factor

κ

of

its

QoS

bound

(in

our

experiments

we

chose

or

failing

if

it

finishes

beyond

κ

times

its

QoS

bound.

For

each

category,

a

business

value

score

is

assigned

to

the

workflow,

with

the

successful

category

assigned

the

highest

positive

score,

followed

by

acceptable

and

then

failing.

The

business

value

point

distribution

is

non-uniform

across

workflows,

further

modelling

cases

where

some

workflows

are

of

higher

priority

than

others.

Each

service

type

is

implemented

by

a

number

of

different

service

providers.

We

assume

that

the

providers

make

service

level

agreements

(SLAs)

to

guarantee

a

level

of

performance

defined

by

the

completion

time

for

completing

a

web

service

invocation.

Although

SLAs

can

be

complex,

in

this

paper

we

assume

for

simplicity

that

the

guarantees

can

take

the

form

of

a

linear

performance

degradation

under

load.

This

guarantee

is

defined

by

several

parameters:

α

is

the

expected

completion

time

(for

example,

on

the

order

of

seconds)

if

the

assigned

workload

of

web

service

requests

is

less

than

or

equal

to

β,

the

maximum

concurrency,

and

if

the

workload

is

higher

than

β,

the

expected

completion

for

a

workload

of

size

ω

is

α+

γ(ω

β)

where

γ

is

a

fractional

coefficient.

In

our

experiments

we

vary

α,

β,

and

γ

with

different

distributions.

Ideally,

all

workflows

would

be

able

to

finish

within

their

QoS

limits

and

thus

maximise

the

aggregate

business

value

across

all

workflows.

However,

because

we

model

service

providers

with

degrading

performance

under

load,

not

all

workflows

will

achieve

their

QoS

limit:

it

may

easily

be

the

case

that

business

processes

are

assigned

to

providers

who

are

overloaded

and

cannot

complete

within

the

respective

workflow"s

QoS

limit.

The

key

research

problem,

then,

is

to

assign

the

business

processes

to

the

web

service

providers

with

the

goal

of

optimising

on

the

aggregate

business

value

of

all

workflows.

Given

that

the

scope

of

the

optimisation

is

the

entire

set

of

workflows,

it

may

be

that

the

best

scheduling

assignments

may

result

in

some

workflows

having

to

fail

in

order

for

more

workflows

to

succeed.

This

intuitive

observation

suggests

that

traditional

scheduling

approaches

such

as

round-robin

or

proportional

assignments

will

not

fare

well,

which

is

what

we

observe

and

discuss

in

Section

On

the

other

hand,

an

exhaustive

search

of

all

the

possible

assignments

will

find

the

best

schedule,

but

the

computational

complexity

is

prohibitively

high.

Suppose

there

are

W

workflows

with

an

average

of

B

business

processes

per

workflow.

Further,

in

the

worst

case

each

business

process

requests

one

service

type,

for

which

there

are

P

providers.

There

are

thus

W

PB

combinations

to

explore

to

find

the

optimal

assignments

of

business

processes

to

providers.

Even

for

small

configurations

(e.g.

W

the

computational

time

for

exhaustive

search

is

significant,

and

in

our

work

we

look

to

scale

these

parameters.

In

the

next

subsection,

discuss

how

a

genetic

search

algorithm

can

be

used

to

converge

toward

the

optimum

scheduling

assignments.

Genetic

algorithm

Given

an

exponential

search

space

of

business

process

assignments

to

web

service

providers,

the

problem

is

to

find

the

optimal

assignment

that

produces

the

overall

highest

aggregate

business

value

across

all

workflows.

To

explore

the

solution

space,

we

use

a

genetic

algorithm

(GA)

search

heuristic

that

simulates

Darwinian

natural

selection

by

having

members

of

a

population

compete

to

survive

in

order

to

pass

their

genetic

chromosomes

onto

the

next

generation;

after

successive

generations,

there

is

a

tendency

for

the

chromosomes

to

converge

toward

the

best

combination

Although

other

search

heuristics

exist

that

can

solve

optimization

problems

(e.g.

simulated

annealing

or

steepest-ascent

hillclimbing),

the

business

process

scheduling

problem

fits

well

with

a

GA

because

potential

solutions

can

be

represented

in

a

matrix

form

and

allows

us

to

use

prior

research

in

effective

GA

chromosome

recombination

to

form

new

members

of

the

population

(e.g.

Figure

An

example

chromosome

representing

a

scheduling

assignment

of

(workflow,service

type)

service

provider.

Each

row

represents

a

workflow,

and

each

column

represents

a

service

type.

For

example,

here

there

are

workflows

to

and

service

types

to

In

workflow

any

request

for

service

type

goes

to

provider

Note

that

the

service

provider

identifier

is

within

a

range

limited

to

its

service

type

(i.e.

its

column),

so

the

listed

for

service

type

is

a

different

server

from

server

in

other

columns.

Chromosome

representation

of

a

solution.

In

Figure

we

show

an

example

chromosome

that

encodes

one

scheduling

assignment.

The

representation

is

a

matrix

that

maps

{workflow,

service

type}

to

a

service

provider.

For

a

business

process

in

workflow

i

and

utilising

service

type

j,

the

(i,

j)th

entry

in

the

table

is

the

identifier

for

the

service

provider

to

which

the

business

process

is

assigned.

Note

that

the

service

provider

identifier

is

within

a

range

limited

to

its

service

type.

GA

execution.

A

GA

proceeds

as

follows.

Initially

a

random

set

of

chromosomes

is

created

for

the

population.

The

chromosomes

are

evaluated

(hashed)

to

some

metric,

and

the

best

ones

are

chosen

to

be

parents.

In

our

problem,

the

evaluation

produces

the

net

business

value

across

all

workflows

after

executing

all

business

processes

once

they

are

assigned

to

their

respective

service

providers

according

to

the

mapping

in

the

chromosome.

The

parents

recombine

to

produce

children,

simulating

sexual

crossover,

and

occasionally

a

mutation

may

arise

which

produces

new

characteristics

that

were

not

available

in

either

parent.

The

principal

idea

is

that

we

would

like

the

children

to

be

different

from

the

parents

(in

order

to

explore

more

of

the

solution

space)

yet

not

too

different

(in

order

to

contain

the

portions

of

the

chromosome

that

result

in

good

scheduling

assignments).

Note

that

finding

the

global

optimum

is

not

guaranteed

because

the

recombination

and

mutation

are

stochastic.

GA

recombination

and

mutation.

As

mentioned,

the

chromosomes

are

matrices

that

represent

scheduling

assignments.

To

simulate

sexual

recombination

of

two

chromosomes

to

produce

a

new

child

chromosome,

we

applied

a

one-point

crossover

scheme

twice

(once

along

each

dimension).

The

crossover

is

best

explained

by

analogy

to

Cartesian

space

as

follows.

A

random

point

is

chosen

in

the

matrix

to

be

coordinate

Matrix

elements

from

quadrants

II

and

IV

from

the

first

parent

and

elements

from

quadrants

I

and

III

from

the

second

parent

are

used

to

create

the

new

child.

This

approach

follows

GA

best

practices

by

keeping

contiguous

chromosome

segments

together

as

they

are

transmitted

from

parent

to

child.

The

uni-chromosome

mutation

scheme

randomly

changes

one

of

the

service

provider

assignments

to

another

provider

within

the

available

range.

Other

recombination

and

mutation

schemes

are

an

area

of

research

in

the

GA

community,

and

we

look

to

explore

new

operators

in

future

work.

GA

evaluation

function.

An

important

GA

component

is

the

evaluation

function.

Given

a

particular

chromosome

representing

one

scheduling

mapping,

the

function

deterministically

calculates

the

net

business

value

across

all

workloads.

The

business

processes

in

each

workload

are

assigned

to

service

providers,

and

each

provider"s

completion

time

is

calculated

based

on

the

service

agreement

guarantee

using

the

parameters

mentioned

in

Section

namely

the

unloaded

completion

time

α,

the

maximum

rency

β,

and

a

coefficient

γ

that

controls

the

linear

performance

degradation

under

heavy

load.

Note

that

the

evaluation

function

can

be

easily

replaced

if

desired;

for

example,

other

evaluation

functions

can

model

different

service

provider

guarantees

or

parallel

workflows.

EXPERIMENTS

AND

RESULTS

In

this

section

we

show

the

benefit

of

using

our

GA-based

scheduler.

Because

we

wanted

to

scale

the

scenarios

up

to

a

large

number

of

workflows

(up

to

in

our

experiments),

we

implemented

a

simulation

program

that

allowed

us

to

vary

parameters

and

to

measure

the

results

with

different

metrics.

The

simulator

was

written

in

standard

C++

and

was

run

on

a

Linux

(Fedora

Core)

desktop

computer

running

at

GHz

with

of

RAM.

We

compared

our

algorithm

against

alternative

candidates:

A

well-known

round-robin

algorithm

that

assigns

each

business

process

in

circular

fashion

to

the

service

providers

for

a

particular

service

type.

This

approach

provides

the

simplest

scheme

for

load-balancing.

A

random-proportional

algorithm

that

proportionally

assigns

business

processes

to

the

service

providers;

that

is,

for

a

given

service

type,

the

service

providers

are

ranked

by

their

guaranteed

completion

time,

and

business

processes

are

assigned

proportionally

to

the

providers

based

on

their

completion

time.

(We

also

tried

a

proportionality

scheme

based

on

both

the

completion

times

and

maximum

concurrency

but

attained

the

same

results,

so

only

the

former

scheme"s

results

are

shown

here.)

A

strawman

greedy

algorithm

that

always

assigns

business

processes

to

the

service

provider

that

has

the

fastest

guaranteed

completion

time.

This

algorithm

represents

a

naive

approach

based

on

greedy,

local

observations

of

each

workflow

without

taking

into

consideration

all

workflows.

In

the

experiments

that

follow,

all

results

were

averaged

across

trials,

and

to

help

normalise

the

effects

of

randomisation

used

during

the

GA,

each

trial

started

by

reading

in

pre-initialised

data

from

disk.

In

Table

we

list

our

experimental

parameters.

In

Figure

we

show

the

results

of

running

our

GA

against

the

three

candidate

alternatives.

The

x-axis

shows

the

number

for

workflows

scaled

up

to

and

the

y-axis

shows

the

aggregate

business

value

for

all

workflows.

As

can

be

seen,

the

GA

consistently

produces

the

highest

business

value

even

as

the

number

of

workflows

grows;

at

workflows,

the

GA

produces

a

improvement

over

the

next-best

alternative.

(Note

that

although

we

are

optimising

against

the

business

value

metric

we

defined

earlier,

genetic

algorithms

are

able

to

converge

towards

the

optimal

value

of

any

metric,

as

long

as

the

evaluation

function

can

consistently

measure

a

chromosome"s

value

with

that

metric.)

As

expected,

the

greedy

algorithm

performs

very

poorly

because

it

does

the

worst

job

at

balancing

load:

all

business

processes

for

a

given

service

type

are

assigned

to

only

one

server

(the

one

advertised

to

have

the

fastest

completion

time),

and

as

more

business

processes

arrive,

the

provider"s

performance

degrades

linearly.

The

round-robin

scheme

is

initially

outperformed

by

the

randomproportional

scheme

up

to

around

workflows

(as

shown

in

the

magnified

graph

of

Figure

but

as

the

number

of

workflows

increases,

the

round-robin

scheme

consistently

wins

over

randomproportional.

The

reason

is

that

although

the

random-proportional

scheme

assigns

business

processes

to

providers

proportionally

according

to

the

advertised

completion

times

(which

is

a

measure

of

the

power

of

the

service

provider),

even

the

best

providers

will

eventually

reach

a

real-world

maximum

concurrency

for

the

large

Total

number

of

workflows

Business

value

scores

of

scheduling

algorithms

Genetic

algorithm

Round

robin

Random

proportional

Greedy

Figure

Net

business

value

scores

of

different

scheduling

algorithms.

200Aggregatebusinessvalueacrossallworkflows

Total

number

of

workflows

Business

value

scores

of

scheduling

algorithms

Genetic

algorithm

Round

robin

Random

proportional

Greedy

Figure

Magnification

of

the

left-most

region

in

Figure

number

of

workflows

that

we

are

considering.

For

a

very

large

number

of

workflows,

the

round-robin

scheme

is

able

to

better

balance

the

load

across

all

service

providers.

To

better

understand

the

behaviour

resulting

from

the

scheduling

assignments,

we

show

the

workflow

completion

results

in

Figures

and

for

and

workflows,

respectively.

These

figures

show

the

percentage

of

workflows

that

are

successful

(can

complete

with

their

QoS

limit),

acceptable

(can

complete

within

times

their

QoS

limit),

and

failed

(cannot

complete

within

times

their

QoS

limit).

The

GA

consistently

produces

the

highest

percentage

of

successful

workflows

(resulting

in

higher

business

values

for

the

aggregate

set

of

workflows).

Further,

the

round-robin

scheme

produces

better

results

than

the

random-proportional

for

a

large

number

of

workflows

but

does

not

perform

as

well

as

the

GA.

In

Figure

we

graph

the

makespan

resulting

from

the

same

experiments

above.

Makespan

is

a

traditional

metric

from

the

job

scheduling

community

measuring

elapsed

time

for

the

last

job

to

complete.

While

useful,

it

does

not

capture

the

high-level

business

value

metric

that

we

are

optimising

against.

Indeed,

the

makespan

is

oblivious

to

the

fact

that

we

provide

multiple

levels

of

completion

(successful,

acceptable,

and

failed)

and

assign

business

value

scores

accordingly.

For

completeness,

we

note

that

the

GA

provides

the

fastest

makespan,

but

it

is

matched

by

the

round

robin

algorithm.

The

GA

produces

better

business

values

(as

shown

in

Figure

because

it

is

able

to

search

the

solution

space

to

find

better

mappings

that

produce

more

successful

workflows

(as

shown

in

Figures

to

We

also

looked

at

the

effect

of

the

scheduling

algorithms

on

balancing

the

load.

Figure

shows

the

percentage

of

services

providers

that

were

accessed

while

the

workflows

ran.

As

expected,

the

greedy

algorithm

always

hits

one

service

provider;

on

the

other

hand,

the

round-robin

algorithm

is

the

fastest

to

spread

the

business

Experimental

parameter

Comment

Workflows

to

Business

processes

per

workflow

uniform

random:

Service

types

Service

providers

per

service

type

uniform

random:

Workflow

QoS

goal

uniform

random:

seconds

Service

provider

completion

time

(α)

uniform

random:

seconds

Service

provider

maximum

concurrency

(β)

uniform

random:

Service

provider

degradation

coefficient

(γ)

uniform

random:

Business

value

for

successful

workflows

uniform

random:

points

Business

value

for

acceptable

workflows

uniform

random:

points

Business

value

for

failed

workflows

uniform

random:

points

GA:

number

of

parents

GA:

number

of

children

GA:

number

of

generations

Table

Experimental

parameters

Failed

Acceptable

(completed

but

not

within

QoS)

Successful

(completed

within

QoS)

RoundRobinRandProportionalGreedyGeneticAlg

Percentageofallworkflows

Workflow

behaviour,

workflows

Figure

Workflow

behaviour

for

workflows.

Failed

Acceptable

(completed

but

not

within

QoS)

Successful

(completed

within

QoS)

Percentageofallworkflows

Workflow

behaviour,

workflows

Figure

Workflow

behaviour

for

workflows.

Failed

Acceptable

(completed

but

not

within

QoS)

Successful

(completed

within

QoS)

Percentageofallworkflows

Workflow

behaviour,

workflows

Figure

Workflow

behaviour

for

workflows.

Makespan[seconds]

Number

of

workflows

Maximum

completion

time

for

all

workflows

Genetic

algorithm

Round

robin

Random

proportional

Greedy

Figure

Maximum

completion

time

for

all

workflows.

This

value

is

the

makespan

metric

used

in

traditional

scheduling

research.

Although

useful,

the

makespan

does

not

take

into

consideration

the

business

value

scoring

in

our

problem

domain.

processes.

Figure

is

the

percentage

of

accessed

service

providers

(that

is,

the

percentage

of

service

providers

represented

in

Figure

that

had

more

assigned

business

processes

than

their

advertised

maximum

concurrency.

For

example,

in

the

greedy

algorithm

only

one

service

provider

is

utilised,

and

this

one

provider

quickly

becomes

saturated.

On

the

other

hand,

the

random-proportional

algorithm

uses

many

service

providers,

but

because

business

processes

are

proportionally

assigned

with

more

assignments

going

to

the

better

providers,

there

is

a

tendency

for

a

smaller

percentage

of

providers

to

become

saturated.

For

completeness,

we

show

the

performance

of

the

genetic

algorithm

itself

in

Figure

The

algorithm

scales

linearly

with

an

increasing

number

of

workflows.

We

note

that

the

round-robin,

random-proportional,

and

greedy

algorithms

all

finished

within

second

even

for

the

largest

workflow

configuration.

However,

we

feel

that

the

benefit

of

finding

much

higher

business

value

scores

justifies

the

running

time

of

the

GA;

further

we

would

expect

that

the

running

time

will

improve

with

both

software

tuning

as

well

as

with

a

computer

faster

than

our

off-the-shelf

PC.

CONCLUSION

Business

processes

within

workflows

can

be

orchestrated

to

access

web

services.

In

this

paper

we

looked

at

multi-tiered

service

provisioning

where

web

service

requests

to

service

types

can

be

mapped

to

different

service

providers.

The

resulting

problem

is

that

in

order

to

support

a

very

large

number

of

workflows,

the

assignment

of

business

process

to

web

service

provider

must

be

intelligent.

We

used

a

business

value

metric

to

measure

the

Percentageofallserviceproviders

Number

of

workflows

Service

providers

utilised

Genetic

algorithm

Round

robin

Random

proportional

Greedy

Figure

The

percentage

of

service

providers

utilized

during

workload

executions.

The

Greedy

algorithm

always

hits

the

one

service

provider,

while

the

Round

Robin

algorithm

spreads

requests

evenly

across

the

providers.

Percentageofallserviceproviders

Number

of

workflows

Service

providers

saturated

Genetic

algorithm

Round

robin

Random

proportional

Greedy

Figure

The

percentage

of

service

providers

that

are

saturated

among

those

providers

who

were

utilized

(that

is,

percentage

of

the

service

providers

represented

in

Figure

A

saturated

service

provider

is

one

whose

workload

is

greater

that

its

advertised

maximum

concurrency.

Runningtimeinseconds

Total

number

of

workflows

Running

time

of

genetic

algorithm

GA

running

time

Figure

Running

time

of

the

genetic

algorithm.

haviour

of

workflows

meeting

or

failing

QoS

values,

and

we

optimised

our

scheduling

to

maximise

the

aggregate

business

value

across

all

workflows.

Since

the

solution

space

of

scheduler

mappings

is

exponential,

we

used

a

genetic

search

algorithm

to

search

the

space

and

converge

toward

the

best

schedule.

With

a

default

configuration

for

all

parameters

and

using

our

business

value

scoring,

the

GA

produced

up

to

business

value

improvement

over

the

next

best

algorithm.

Finally,

because

a

genetic

algorithm

will

converge

towards

the

optimal

value

using

any

metric

(even

other

than

the

business

value

metric

we

used),

we

believe

our

approach

has

strong

potential

for

continuing

work.

In

future

work,

we

look

to

acquire

real-world

traces

of

web

service

instances

in

order

to

get

better

estimates

of

service

agreement

guarantees,

although

we

expect

that

such

guarantees

between

the

providers

and

their

consumers

are

not

generally

available

to

the

public.

We

will

also

look

at

other

QoS

metrics

such

as

CPU

and

I/O

usage.

For

example,

we

can

analyse

transfer

costs

with

varying

bandwidth,

latency,

data

size,

and

data

distribution.

Further,

we

hope

to

improve

our

genetic

algorithm

and

compare

it

to

more

scheduler

alternatives.

Finally,

since

our

work

is

complementary

to

existing

work

in

web

services

choreography

(because

we

rely

on

pre-configured

workflows),

we

look

to

integrate

our

approach

with

available

web

service

workflow

systems

expressed

in

BPEL.

REFERENCES

A.

Ankolekar,

et

al.

DAML-S:

Semantic

Markup

For

Web

Services,

In

Proc.

of

the

Int"l

Semantic

Web

Working

Symposium,

L.

Davis.

Job

Shop

Scheduling

with

Genetic

Algorithms,

In

Proc.

of

the

Int"l

Conference

on

Genetic

Algorithms,

H.-L.

Fang,

P.

Ross,

and

D.

Corne.

A

Promising

Genetic

Algorithm

Approach

to

Job-Shop

Scheduling,

Rescheduling,

and

Open-Shop

Scheduling

Problems

In

Proc.

on

the

Int"l

Conference

on

Genetic

Algorithms,

M.

Gary

and

D.

Johnson.

Computers

and

Intractability:

A

Guide

to

the

Theory

of

NP-Completeness,

Freeman,

J.

Holland.

Adaptation

in

Natural

and

Artificial

Systems:

An

Introductory

Analysis

with

Applications

to

Biology,

Control,

and

Artificial

Intelligence,

MIT

Press,

D.

Goldberg.

Genetic

Algorithms

in

Search,

Optimization

and

Machine

Learning,

Kluwer

Academic

Publishers,

Business

Processes

in

a

Web

Services

World,

webservices/library/ws-bpelwp/.

G.

Soundararajan,

K.

Manassiev,

J.

Chen,

A.

Goel,

and

C.

Amza.

Back-end

Databases

in

Shared

Dynamic

Content

Server

Clusters,

In

Proc.

of

the

IEEE

Int"l

Conference

on

Autonomic

Computing,

B.

Srivastava

and

J.

Koehler.

Web

Service

Composition

Current

Solutions

and

Open

Problems,

ICAP,

B.

Urgaonkar,

P.

Shenoy,

A.

Chandra,

and

P.

Goyal.

Dynamic

Provisioning

of

Multi-Tier

Internet

Applications,

In

Proc.

of

the

IEEE

Int"l

Conference

on

Autonomic

Computing,

L.

Zeng,

B.

Benatallah,

M.

Dumas,

J.

Kalagnanam,

and

Q.

Sheng.

Quality

Driven

Web

Services

Composition,

In

Proc.

of

the

WWW

Conference,

O O O O B I O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B I O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B I O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B I O O O O O O O O O O B I O O O O O O O O O O O O O O O O B I O O O O O O O B I O O O O B I I O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B I O O O O B I O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B I O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B I O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B I O O B I O O O B I O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B I O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B I I O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B I O O O B I O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B I O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B I O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B I I O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B I O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B I O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B I O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B I O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B I O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B I O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B I O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B I I O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B I I O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B I O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B I O O O O O O O B I I O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B I I O O O O O O O O O O O O O O O O O O O O O O B I O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B I O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B I O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O

end-to-end workflow composition
service request
multi-tiered system
multi-organisation environment
qos-defined limit
qo
workﬂows

streamlined functionality
scheduling agent
heuristic
scheduling service
business process workflow
business value metric
web service
schedule