Approximately-Strategyproof

and

Tractable

Multi-Unit

Auctions

Anshul

Kothari∗

David

C.

Parkes†

Subhash

Suri∗

ABSTRACT

We

present

an

approximately-efficient

and

approximatelystrategyproof

auction

mechanism

for

a

single-good

multi-unit

allocation

problem.

The

bidding

language

in

our

auctions

allows

marginal-decreasing

piecewise

constant

curves.

First,

we

develop

a

fully

polynomial-time

approximation

scheme

for

the

multi-unit

allocation

problem,

which

computes

a

)approximation

in

worst-case

time

T

given

n

bids

each

with

a

constant

number

of

pieces.

Second,

we

embed

this

approximation

scheme

within

a

Vickrey-Clarke-Groves

(VCG)

mechanism

and

compute

payments

to

n

agents

for

an

asymptotic

cost

of

O(T

log

n).

The

maximal

possible

gain

from

manipulation

to

a

bidder

in

the

combined

scheme

is

bounded

by

)V

where

V

is

the

total

surplus

in

the

efficient

outcome.

Categories

and

Subject

Descriptors

[Theory

of

Computation]:

Analysis

of

Algorithms

and

Problem

Complexity;

[Computer

Applications]:

Social

and

Behavioral

Sciences-Economics.

General

Terms

Algorithms,

Economics.

INTRODUCTION

In

this

paper

we

present

a

fully

polynomial-time

approximation

scheme

for

the

single-good

multi-unit

auction

problem.

Our

scheme

is

both

approximately

efficient

and

approximately

strategyproof.

The

auction

settings

considered

in

our

paper

are

motivated

by

recent

trends

in

electronic

commerce;

for

instance,

corporations

are

increasingly

using

auctions

for

their

strategic

sourcing.

We

consider

both

a

reverse

auction

variation

and

a

forward

auction

variation,

and

propose

a

compact

and

expressive

bidding

language

that

allows

marginal-decreasing

piecewise

constant

curves.

In

the

reverse

auction,

we

consider

a

single

buyer

with

a

demand

for

M

units

of

a

good

and

n

suppliers,

each

with

a

marginal-decreasing

piecewise-constant

cost

function.

In

addition,

each

supplier

can

also

express

an

upper

bound,

or

capacity

constraint

on

the

number

of

units

she

can

supply.

The

reverse

variation

models,

for

example,

a

procurement

auction

to

obtain

raw

materials

or

other

services

(e.g.

circuit

boards,

power

suppliers,

toner

cartridges),

with

flexible-sized

lots.

In

the

forward

auction,

we

consider

a

single

seller

with

M

units

of

a

good

and

n

buyers,

each

with

a

marginal-decreasing

piecewise-constant

valuation

function.

A

buyer

can

also

express

a

lower

bound,

or

minimum

lot

size,

on

the

number

of

units

she

demands.

The

forward

variation

models,

for

example,

an

auction

to

sell

excess

inventory

in

flexible-sized

lots.

We

consider

the

computational

complexity

of

implementing

the

Vickrey-Clarke-Groves

mechanism

for

the

multiunit

auction

problem.

The

Vickrey-Clarke-Groves

(VCG)

mechanism

has

a

number

of

interesting

economic

properties

in

this

setting,

including

strategyproofness,

such

that

truthful

bidding

is

a

dominant

strategy

for

buyers

in

the

forward

auction

and

sellers

in

the

reverse

auction,

and

allocative

efficiency,

such

that

the

outcome

maximizes

the

total

surplus

in

the

system.

However,

as

we

discuss

in

Section

the

application

of

the

VCG-based

approach

is

limited

in

the

reverse

direction

to

instances

in

which

the

total

payments

to

the

sellers

are

less

than

the

value

of

the

outcome

to

the

buyer.

Otherwise,

either

the

auction

must

run

at

a

loss

in

these

instances,

or

the

buyer

cannot

be

expected

to

voluntarily

choose

to

participate.

This

is

an

example

of

the

budget-deficit

problem

that

often

occurs

in

efficient

mechanism

design

The

computational

problem

is

interesting,

because

even

with

marginal-decreasing

bid

curves,

the

underlying

allocation

problem

turns

out

to

(weakly)

intractable.

For

instance,

the

classic

knapsack

is

a

special

case

of

this

We

model

the

However,

the

problem

can

be

solved

easily

by

a

greedy

scheme

if

we

remove

all

capacity

constraints

from

the

seller

and

all

allocation

problem

as

a

novel

and

interesting

generalization

of

the

classic

knapsack

problem,

and

develop

a

fully

polynomialtime

approximation

scheme,

computing

a

)-approximation

in

worst-case

time

T

/ε),

where

each

bid

has

a

fixed

number

of

piecewise

constant

pieces.

Given

this

scheme,

a

straightforward

computation

of

the

VCG

payments

to

all

n

agents

requires

time

O(nT).

We

compute

approximate

VCG

payments

in

worst-case

time

O(αT

log(αn/ε)),

where

α

is

a

constant

that

quantifies

a

reasonable

no-monopoly

assumption.

Specifically,

in

the

reverse

auction,

suppose

that

C(I)

is

the

minimal

cost

for

procuring

M

units

with

all

sellers

I,

and

C(I

i)

is

the

minimal

cost

without

seller

i.

Then,

the

constant

α

is

defined

as

an

upper

bound

for

the

ratio

C(I

\i)/C(I),

over

all

sellers

i.

This

upper-bound

tends

to

as

the

number

of

sellers

increases.

The

approximate

VCG

mechanism

is

ε

)-strategyproof

for

an

approximation

to

within

of

the

optimal

allocation.

This

means

that

a

bidder

can

gain

at

most

ε

)V

from

a

nontruthful

bid,

where

V

is

the

total

surplus

from

the

efficient

allocation.

As

such,

this

is

an

example

of

a

computationally-tractable

ε-dominance

In

practice,

we

can

have

good

confidence

that

bidders

without

good

information

about

the

bidding

strategies

of

other

participants

will

have

little

to

gain

from

attempts

at

manipulation.

Section

formally

defines

the

forward

and

reverse

auctions,

and

defines

the

VCG

mechanisms.

We

also

prove

our

claims

about

ε-strategyproofness.

Section

provides

the

generalized

knapsack

formulation

for

the

multi-unit

allocation

problems

and

introduces

the

fully

polynomial

time

approximation

scheme.

Section

defines

the

approximation

scheme

for

the

payments

in

the

VCG

mechanism.

Section

concludes.

Related

Work

There

has

been

considerable

interest

in

recent

years

in

characterizing

polynomial-time

or

approximable

special

cases

of

the

general

combinatorial

allocation

problem,

in

which

there

are

multiple

different

items.

The

combinatorial

allocation

problem

(CAP)

is

both

NP-complete

and

inapproximable

(e.g.

Although

some

polynomial-time

cases

have

been

identified

for

the

CAP

introducing

an

expressive

exclusive-or

bidding

language

quickly

breaks

these

special

cases.

We

identify

a

non-trivial

but

approximable

allocation

problem

with

an

expressive

exclusiveor

bidding

language-the

bid

taker

in

our

setting

is

allowed

to

accept

at

most

one

point

on

the

bid

curve.

The

idea

of

using

approximations

within

mechanisms,

while

retaining

either

full-strategyproofness

or

ε-dominance

has

received

some

previous

attention.

For

instance,

Lehmann

et

al.

propose

a

greedy

and

strategyproof

approximation

to

a

single-minded

combinatorial

auction

problem.

Nisan

Ronen

discussed

approximate

VCG-based

mechanisms,

but

either

appealed

to

particular

maximal-in-range

approximations

to

retain

full

strategyproofness,

or

to

resource-bounded

agents

with

information

or

computational

limitations

on

the

ability

to

compute

strategies.

Feigenminimum-lot

size

constraints

from

the

buyers.

However,

this

may

not

be

an

example

of

what

Feigenbaum

Shenker

refer

to

as

a

tolerably-manipulable

mechanism

because

we

have

not

tried

to

bound

the

effect

of

such

a

manipulation

on

the

efficiency

of

the

outcome.

VCG

mechanism

do

have

a

natural

self-correcting

property,

though,

because

a

useful

manipulation

to

an

agent

is

a

reported

value

that

improves

the

total

value

of

the

allocation

based

on

the

reports

of

other

agents

and

the

agent"s

own

value.

baum

Shenker

have

defined

the

concept

of

strategically

faithful

approximations,

and

proposed

the

study

of

approximations

as

an

important

direction

for

algorithmic

mechanism

design.

Schummer

and

Parkes

et

al

have

previously

considered

ε-dominance,

in

the

context

of

economic

impossibility

results,

for

example

in

combinatorial

exchanges.

Eso

et

al.

have

studied

a

similar

procurement

problem,

but

for

a

different

volume

discount

model.

This

earlier

work

formulates

the

problem

as

a

general

mixed

integer

linear

program,

and

gives

some

empirical

results

on

simulated

data.

Kalagnanam

et

al.

address

double

auctions,

where

multiple

buyers

and

sellers

trade

a

divisible

good.

The

focus

of

this

paper

is

also

different:

it

investigates

the

equilibrium

prices

using

the

demand

and

supply

curves,

whereas

our

focus

is

on

efficient

mechanism

design.

Ausubel

has

proposed

an

ascending-price

multi-unit

auction

for

buyers

with

marginal-decreasing

values

with

an

interpretation

as

a

primal-dual

algorithm

APPROXIMATELY-STRATEGYPROOF

VCG

AUCTIONS

In

this

section,

we

first

describe

the

marginal-decreasing

piecewise

bidding

language

that

is

used

in

our

forward

and

reverse

auctions.

Continuing,

we

introduce

the

VCG

mechanism

for

the

problem

and

the

ε-dominance

results

for

approximations

to

VCG

outcomes.

We

also

discuss

the

economic

properties

of

VCG

mechanisms

in

these

forward

and

reverse

auction

multi-unit

settings.

Marginal-Decreasing

Piecewise

Bids

We

provide

a

piecewise-constant

and

marginal-decreasing

bidding

language.

This

bidding

language

is

expressive

for

a

natural

class

of

valuation

and

cost

functions:

fixed

unit

prices

over

intervals

of

quantities.

See

Figure

for

an

example.

In

addition,

we

slightly

relax

the

marginal-decreasing

requirement

to

allow:

a

bidder

in

the

forward

auction

to

state

a

minimal

purchase

amount,

such

that

she

has

zero

value

for

quantities

smaller

than

that

amount;

a

seller

in

the

reverse

auction

to

state

a

capacity

constraint,

such

that

she

has

an

effectively

infinite

cost

to

supply

quantities

in

excess

of

a

particular

amount.

Reverse

Auction

Bid

Quantity

Price

Quantity

Price

Forward

Auction

Bid

Figure

Marginal-decreasing,

piecewise

constant

bids.

In

the

forward

auction

bid,

the

bidder

offers

per

unit

for

quantity

in

the

range

per

unit

in

the

range

and

in

the

range

Her

valuation

is

zero

for

quantities

outside

the

range

In

the

reverse

auction

bid,

the

cost

of

the

seller

is

outside

the

range

In

detail,

in

a

forward

auction,

a

bid

from

buyer

i

can

be

written

as

a

list

of

(quantity-range,

unit-price)

tuples,

i

i

i

i

i

i

with

an

upper

bound

umi

i

on

the

quantity.

The

interpretation

is

that

the

bidder"s

valuation

in

the

(semi-open)

quantity

range

[uj

i

i

is

pj

i

for

each

unit.

Additionally,

it

is

assumed

that

the

valuation

is

for

quantities

less

than

i

as

well

as

for

quantities

more

than

um

i

This

is

implemented

by

adding

two

dummy

bid

tuples,

with

zero

prices

in

the

range

i

and

(umi

i

We

interpret

the

bid

list

as

defining

a

price

function,

pbid,i(q)

qpj

i

if

uj

i

q

i

where

j

mi

In

order

to

resolve

the

boundary

condition,

we

assume

that

the

bid

price

for

the

upper

bound

quantity

umi

i

is

pbid,i(umi

i

umi

i

i

A

seller"s

bid

is

similarly

defined

in

the

reverse

auction.

The

interpretation

is

that

the

bidder"s

cost

in

the

(semi-open)

quantity

range

[uj

i

i

is

pj

i

for

each

unit.

Additionally,

it

is

assumed

that

the

cost

is

for

quantities

less

than

i

as

well

as

for

quantities

more

than

um

i

Equivalently,

the

unit

prices

in

the

ranges

i

and

(um

i

are

infinity.

We

interpret

the

bid

list

as

defining

a

price

function,

pask,i(q)

qpj

i

if

uj

i

q

i

VCG-Based

Multi-Unit

Auctions

We

construct

the

tractable

and

approximately-strategyproof

multiunit

auctions

around

a

VCG

mechanism.

We

assume

that

all

agents

have

quasilinear

utility

functions;

that

is,

ui(q,

p)

vi(q)−

p,

for

a

buyer

i

with

valuation

vi(q)

for

q

units

at

price

p,

and

ui(q,

p)

p

ci(q)

for

a

seller

i

with

cost

ci(q)

at

price

p.

This

is

a

standard

assumption

in

the

auction

literature,

equivalent

to

assuming

risk-neutral

agents

We

will

use

the

term

payoff

interchangeably

for

utility.

In

the

forward

auction,

there

is

a

seller

with

M

units

to

sell.

We

assume

that

this

seller

has

no

intrinsic

value

for

the

items.

Given

a

set

of

bids

from

I

agents,

let

V

(I)

denote

the

maximal

revenue

to

the

seller,

given

that

at

most

one

point

on

the

bid

curve

can

be

selected

from

each

agent

and

no

more

than

M

units

of

the

item

can

be

sold.

Let

x∗

(x∗

x∗

N

denote

the

solution

to

this

winner-

determination

problem,

where

x∗

i

is

the

number

of

units

sold

to

agent

i.

Similarly,

let

V

(I

i)

denote

the

maximal

revenue

to

the

seller

without

bids

from

agent

i.

The

VCG

mechanism

is

defined

as

follows:

Receive

piecewise-constant

bid

curves

and

capacity

constraints

from

all

the

buyers.

Implement

the

outcome

x∗

that

solves

the

winner-determination

problem

with

all

buyers.

Collect

payment

pvcg,i

pbid,i(x∗

i

[V

(I)

V

(I

i)]

from

each

buyer,

and

pass

the

payments

to

the

seller.

In

this

forward

auction,

the

VCG

mechanism

is

strategyproof

for

buyers,

which

means

that

truthful

bidding

is

a

dominant

strategy,

i.e.

utility

maximizing

whatever

the

bids

of

other

buyers.

In

addition,

the

VCG

mechanism

is

allocatively-efficient,

and

the

payments

from

each

buyer

are

always

Moreover,

each

buyer

pays

less

than

its

value,

and

receives

payoff

V

(I)−V

(I

i)

in

equilibrium;

this

is

precisely

the

marginal-value

that

buyer

i

contributes

to

the

economic

efficiency

of

the

system.

In

the

reverse

auction,

there

is

a

buyer

with

M

units

to

buy,

and

n

suppliers.

We

assume

that

the

buyer

has

value

V

to

purchase

all

M

units,

but

zero

value

otherwise.

To

simplify

the

mechanism

design

problem

we

assume

that

the

buyer

will

truthfully

announce

this

value

to

the

The

In

fact,

the

VCG

mechanism

maximizes

the

expected

payoff

to

the

seller

across

all

efficient

mechanisms,

even

allowing

for

Bayesian-Nash

implementations

Without

this

assumption,

the

Myerson-Satterthwaite

impossibility

result

would

already

imply

that

we

should

not

expect

an

efficient

trading

mechanism

in

this

setting.

determination

problem

in

the

reverse

auction

is

to

determine

the

allocation,

x∗

that

minimizes

the

cost

to

the

buyer,

or

forfeits

trade

if

the

minimal

cost

is

greater

than

value,

V

Let

C(I)

denote

the

minimal

cost

given

bids

from

all

sellers,

and

let

C(I

\i)

denote

the

minimal

cost

without

bids

from

seller

i.

We

can

assume,

without

loss

of

generality,

that

there

is

an

efficient

trade

and

V

C(I).

Otherwise,

then

the

efficient

outcome

is

no

trade,

and

the

outcome

of

the

VCG

mechanism

is

no

trade

and

no

payments.

The

VCG

mechanism

implements

the

outcome

x∗

that

minimizes

cost

based

on

bids

from

all

sellers,

and

then

provides

payment

pvcg,i

pask,i(x∗

i

)+[V

V

−C(I\i))]

to

each

seller.

The

total

payment

is

collected

from

the

buyer.

Again,

in

equilibrium

each

seller"s

payoff

is

exactly

the

marginal-value

that

the

seller

contributes

to

the

economic

efficiency

of

the

system;

in

the

simple

case

that

V

C(I

i)

for

all

sellers

i,

this

is

precisely

C(I

i)

C(I).

Although

the

VCG

mechanism

remains

strategyproof

for

sellers

in

the

reverse

direction,

its

applicability

is

limited

to

cases

in

which

the

total

payments

to

the

sellers

are

less

than

the

buyer"s

value.

Otherwise,

there

will

be

instances

in

which

the

buyer

will

not

choose

to

voluntarily

participate

in

the

mechanism,

based

on

its

own

value

and

its

beliefs

about

the

costs

of

sellers.

This

leads

to

a

loss

in

efficiency

when

the

buyer

chooses

not

to

participate,

because

efficient

trades

are

missed.

This

problem

with

the

size

of

the

payments,

does

not

occur

in

simple

single-item

reverse

auctions,

or

even

in

multi-unit

reverse

auctions

with

a

buyer

that

has

a

constant

marginal-valuation

for

each

additional

item

that

she

Intuitively,

the

problem

occurs

in

the

reverse

multi-unit

setting

because

the

buyer

demands

a

fixed

number

of

items,

and

has

zero

value

without

them.

This

leads

to

the

possibility

of

the

trade

being

contingent

on

the

presence

of

particular,

so-called

pivotal

sellers.

Define

a

seller

i

as

pivotal,

if

C(I)

V

but

C(I\i)

V

In

words,

there

would

be

no

efficient

trade

without

the

seller.

Any

time

there

is

a

pivotal

seller,

the

VCG

payments

to

that

seller

allow

her

to

extract

all

of

the

surplus,

and

the

payments

are

too

large

to

sustain

with

the

buyer"s

value

unless

this

is

the

only

winning

seller.

Concretely,

we

have

this

participation

problem

in

the

reverse

auction

when

the

total

payoff

to

the

sellers,

in

equilibrium,

exceeds

the

total

payoff

from

the

efficient

allocation:

V

C(I)

i

[V

C(I)

V

C(I

i))]

As

stated

above,

first

notice

that

we

require

V

C(I

i)

for

all

sellers

i.

In

other

words,

there

must

be

no

pivotal

sellers.

Given

this,

it

is

then

necessary

and

sufficient

that:

V

C(I)

i

(C(I

i)

C(I))

To

make

the

reverse

auction

symmetric

with

the

forward

direction,

we

would

need

a

buyer

with

a

constant

marginal-value

to

buy

the

first

M

units,

and

zero

value

for

additional

units.

The

payments

to

the

sellers

would

never

exceed

the

buyer"s

value

in

this

case.

Conversely,

to

make

the

forward

auction

symmetric

with

the

reverse

auction,

we

would

need

a

seller

with

a

constant

(and

high)

marginal-cost

to

sell

anything

less

than

the

first

M

units,

and

then

a

low

(or

zero)

marginal

cost.

The

total

payments

received

by

the

seller

can

be

less

than

the

seller"s

cost

for

the

outcome

in

this

case.

In

words,

the

surplus

of

the

efficient

allocation

must

be

greater

than

the

total

marginal-surplus

provided

by

each

Consider

an

example

with

agents

and

V

and

Condition

holds

when

and

but

not

when

and

In

the

first

case,

the

agent

payoffs

π

where

is

the

seller,

is

In

the

second

case,

the

payoffs

are

π

One

thing

we

do

know,

because

the

VCG

mechanism

will

maximize

the

payoff

to

the

buyer

across

all

efficient

mechanisms

is

that

whenever

Eq.

is

not

satisfied

there

can

be

no

efficient

auction

ε-Strategyproofness

We

now

consider

the

same

VCG

mechanism,

but

with

an

approximation

scheme

for

the

underlying

allocation

problem.

We

derive

an

ε-strategyproofness

result,

that

bounds

the

maximal

gain

in

payoff

that

an

agent

can

expect

to

achieve

through

a

unilateral

deviation

from

following

a

simple

truth-revealing

strategy.

We

describe

the

result

for

the

forward

auction

direction,

but

it

is

quite

a

general

observation.

As

before,

let

V

(I)

denote

the

value

of

the

optimal

solution

to

the

allocation

problem

with

truthful

bids

from

all

agents,

and

V

(I

\i)

denote

the

value

of

the

optimal

solution

computed

without

bids

from

agent

i.

Let

ˆV

(I)

and

ˆV

(I

i)

denote

the

value

of

the

allocation

computed

with

an

approximation

scheme,

and

assume

that

the

approximation

satisfies:

ˆV

(I)

V

(I)

for

some

We

provide

such

an

approximation

scheme

for

our

setting

later

in

the

paper.

Let

ˆx

denote

the

allocation

implemented

by

the

approximation

scheme.

The

payoff

to

agent

i,

for

announcing

valuation

ˆvi,

is:

vi(ˆxi)

j=i

ˆvj

(ˆxj)

ˆV

(I

i)

The

final

term

is

independent

of

the

agent"s

announced

value,

and

can

be

ignored

in

an

incentive-analysis.

However,

agent

i

can

try

to

improve

its

payoff

through

the

effect

of

its

announced

value

on

the

allocation

ˆx

implemented

by

the

mechanism.

In

particular,

agent

i

wants

the

mechanism

to

select

ˆx

to

maximize

the

sum

of

its

true

value,

vi(ˆxi),

and

the

reported

value

of

the

other

agents,

Èj=i

ˆvj

(ˆxj).

If

the

mechanism"s

allocation

algorithm

is

optimal,

then

all

the

agent

needs

to

do

is

truthfully

state

its

value

and

the

mechanism

will

do

the

rest.

However,

faced

with

an

approximate

allocation

algorithm,

the

agent

can

try

to

improve

its

payoff

by

announcing

a

value

that

corrects

for

the

approximation,

and

causes

the

approximation

algorithm

to

implement

the

allocation

that

exactly

maximizes

the

total

reported

value

of

the

other

agents

together

with

its

own

actual

value

This

condition

is

implied

by

the

agents

are

substitutes

requirement

that

has

received

some

attention

in

the

combinatorial

auction

literature

because

it

characterizes

the

case

in

which

VCG

payments

can

be

supported

in

a

competitive

equilibrium.

Useful

characterizations

of

conditions

that

satisfy

agents

are

substitutes,

in

terms

of

the

underlying

valuations

of

agents

have

proved

quite

elusive.

Moreover,

although

there

is

a

small

literature

on

maximallyefficient

mechanisms

subject

to

requirements

of

voluntaryparticipation

and

budget-balance

(i.e.

with

the

mechanism

neither

introducing

or

removing

money),

analytic

results

are

only

known

for

simple

problems

(e.g.

We

can

now

analyze

the

best

possible

gain

from

manipulation

to

an

agent

in

our

setting.

We

first

assume

that

the

other

agents

are

truthful,

and

then

relax

this.

In

both

cases,

the

maximal

benefit

to

agent

i

occurs

when

the

initial

approximation

is

worst-case.

With

truthful

reports

from

other

agents,

this

occurs

when

the

value

of

choice

ˆx

is

V

ε).

Then,

an

agent

could

hope

to

receive

an

improved

payoff

of:

V

(I)

V

(I)

ε

ε

ε

V

(I)

This

is

possible

if

the

agent

is

able

to

select

a

reported

type

to

correct

the

approximation

algorithm,

and

make

the

algorithm

implement

the

allocation

with

value

V

(I).

Thus,

if

other

agents

are

truthful,

and

with

a

ε)-approximation

scheme

to

the

allocation

problem,

then

no

agent

can

improve

its

payoff

by

more

than

a

factor

ε)

of

the

value

of

the

optimal

solution.

The

analysis

is

very

similar

when

the

other

agents

are

not

truthful.

In

this

case,

an

individual

agent

can

improve

its

payoff

by

no

more

than

a

factor

of

the

value

of

the

optimal

solution

given

the

values

reported

by

the

other

agents.

Let

V

in

the

following

theorem

define

the

total

value

of

the

efficient

allocation,

given

the

reported

values

of

agents

j

i,

and

the

true

value

of

agent

i.

THEOREM

A

VCG-based

mechanism

with

a

ε)allocation

algorithm

is

−V

strategyproof

for

agent

i,

and

agent

i

can

gain

at

most

this

payoff

through

some

non-truthful

strategy.

Notice

that

we

did

not

need

to

bound

the

error

on

the

allocation

problems

without

each

agent,

because

the

-strategyproofness

result

follows

from

the

accuracy

of

the

first-term

in

the

VCG

payment

and

is

independent

of

the

accuracy

of

the

second-term.

However,

the

accuracy

of

the

solution

to

the

problem

without

each

agent

is

important

to

implement

a

good

approximation

to

the

revenue

properties

of

the

VCG

mechanism.

THEGENERALIZED

KNAPSACK

PROBLEM

In

this

section,

we

design

a

fully

polynomial

approximation

scheme

for

the

generalized

knapsack,

which

models

the

winnerdetermination

problem

for

the

VCG-based

multi-unit

auctions.

We

describe

our

results

for

the

reverse

auction

variation,

but

the

formulation

is

completely

symmetric

for

the

forward-auction.

In

describing

our

approximation

scheme,

we

begin

with

a

simple

property

(the

Anchor

property)

of

an

optimal

knapsack

solution.

We

use

this

property

to

develop

an

time

for

the

generalized

knapsack.

In

turn,

we

use

this

basic

approximation

to

develop

our

fully

polynomial-time

approximation

scheme

(FPTAS).

One

of

the

major

appeals

of

our

piecewise

bidding

language

is

its

compact

representation

of

the

bidder"s

valuation

functions.

We

strive

to

preserve

this,

and

present

an

approximation

scheme

that

will

depend

only

on

the

number

of

bidders,

and

not

the

maximum

quantity,

M,

which

can

be

very

large

in

realistic

procurement

settings.

The

FPTAS

implements

an

ε)

approximation

to

the

optimal

solution

x∗

in

worst-case

time

T

/ε),

where

n

is

the

number

of

bidders,

and

where

we

assume

that

the

piecewise

bid

for

each

bidder

has

pieces.

The

dependence

on

the

number

of

pieces

is

also

polynomial:

if

each

bid

has

a

maximum

of

c

pieces,

then

the

running

time

can

be

derived

by

substituting

nc

for

each

occurrence

of

n.

Preliminaries

Before

we

begin,

let

us

recall

the

classic

knapsack

problem:

we

are

given

a

set

of

n

items,

where

the

item

i

has

value

vi

and

size

si,

and

a

knapsack

of

capacity

M;

all

sizes

are

integers.

The

goal

is

to

determine

a

subset

of

items

of

maximum

value

with

total

size

at

most

M.

Since

we

want

to

focus

on

a

reverse

auction,

the

equivalent

knapsack

problem

will

be

to

choose

a

set

of

items

with

minimum

value

(i.e.

cost)

whose

size

exceeds

M.

The

generalized

knapsack

problem

of

interest

to

us

can

be

defined

as

follows:

Generalized

Knapsack:

Instance:

A

target

M,

and

a

set

of

n

lists,

where

the

ith

list

has

the

form

Bi

i

i

i

i

(umi

i

(i),

where

uj

i

are

increasing

with

j

and

pj

i

are

decreasing

with

j,

and

uj

i

pj

i

M

are

positive

integers.

Problem:

Determine

a

set

of

integers

xj

i

such

that

(One

per

list)

At

most

one

xj

i

is

non-zero

for

any

i,

(Membership)

xj

i

implies

xj

i

[uj

i

i

(Target)

Èi

Èj

xj

i

M,

and

(Objective)

Èi

Èj

pj

i

xj

i

is

minimized.

This

generalized

knapsack

formulation

is

a

clear

generalization

of

the

classic

knapsack.

In

the

latter,

each

list

consists

of

a

single

point

(si,

The

connection

between

the

generalized

knapsack

and

our

auction

problem

is

transparent.

Each

list

encodes

a

bid,

representing

multiple

mutually

exclusive

quantity

intervals,

and

one

can

choose

any

quantity

in

an

interval,

but

at

most

one

interval

can

be

selected.

Choosing

interval

[uj

i

i

has

cost

pj

i

per

unit.

The

goal

is

to

procure

at

least

M

units

of

the

good

at

minimum

possible

cost.

The

problem

has

some

flavor

of

the

continuous

knapsack

problem.

However,

there

are

two

major

differences

that

make

our

problem

significantly

more

difficult:

intervals

have

boundaries,

and

so

to

choose

interval

[uj

i

i

requires

that

at

least

uj

i

and

at

most

i

units

must

be

taken;

unlike

the

classic

knapsack,

we

cannot

sort

the

items

(bids)

by

value/size,

since

different

intervals

in

one

list

have

different

unit

costs.

A

Scheme

We

begin

with

a

definition.

Given

an

instance

of

the

generalized

knapsack,

we

call

each

tuple

tj

i

(uj

i

pj

i

an

anchor.

Recall

that

these

tuples

represent

the

breakpoints

in

the

piecewise

constant

curve

bids.

We

say

that

the

size

of

an

anchor

tj

i

is

uj

i

In

fact,

because

of

the

one

per

list

constraint,

the

generalized

problem

is

closer

in

spirit

to

the

multiple

choice

knapsack

problem

where

the

underling

set

of

items

is

partitioned

into

disjoint

subsets

Uk,

and

one

can

choose

at

most

one

item

from

each

subset.

PTAS

do

exist

for

this

problem

and

indeed,

one

can

convert

our

problem

into

a

huge

instance

of

the

multiple

choice

knapsack

problem,

by

creating

one

group

for

each

list;

put

a

(quantity,

price)

point

tuple

(x,

p)

for

each

possible

quantity

for

a

bidder

into

his

group

(subset).

However,

this

conversion

explodes

the

problem

size,

making

it

infeasible

for

all

but

the

most

trivial

instances.

the

minimum

number

of

units

available

at

this

anchor"s

price

pj

i

The

cost

of

the

anchor

tj

i

is

defined

to

be

the

minimum

total

price

associated

with

this

tuple,

namely,

cost(tj

i

pj

i

uj

i

if

j

mi,

and

cost(tmi

i

i

umi

i

In

a

feasible

solution

xn}

of

the

generalized

knapsack,

we

say

that

an

element

xi

is

an

anchor

if

xi

uj

i

for

some

anchor

uj

i

Otherwise,

we

say

that

xi

is

midrange.

We

observe

that

an

optimal

knapsack

solution

can

always

be

constructed

so

that

at

most

one

solution

element

is

midrange.

If

there

are

two

midrange

elements

x

and

x

for

bids

from

two

different

agents,

with

x

x

then

we

can

increment

x

and

decrement

x,

until

one

of

them

becomes

an

anchor.

See

Figure

for

an

example.

LEMMA

[Anchor

Property]

There

exists

an

optimal

solution

of

the

generalized

knapsack

problem

with

at

most

one

midrange

element.

All

other

elements

are

anchors.

midrange

bid

Price

Quantity

Price

Quantity

(i)

Optimal

solution

with

midrange

bids

(ii)

Optimal

soltution

with

Figure

(i)

An

optimal

solution

with

more

than

one

bid

not

anchored

(ii)

an

optimal

solution

with

only

one

bid

not

anchored.

We

use

the

anchor

property

to

first

obtain

a

polynomial-time

scheme.

We

do

this

by

solving

several

instances

of

a

restricted

generalized-knapsack

problem,

which

we

call

iKnapsack,

where

one

element

is

forced

to

be

midrange

for

a

particular

interval.

Specifically,

suppose

element

x

for

agent

l

is

forced

to

lie

in

its

jth

range,

[uj

while

all

other

elements,

xn,

are

required

to

be

anchors,

or

zero.

This

corresponds

to

the

restricted

problem

iKnapsack(

j),

in

which

the

goal

is

to

obtain

at

least

M

uj

units

with

minimum

cost.

Element

x

is

assumed

to

have

already

contributed

uj

units.

The

value

of

a

solution

to

iKnapsack(

j)

represents

the

minimal

additional

cost

to

purchase

the

rest

of

the

units.

We

create

n

groups

of

potential

anchors,

where

ith

group

contains

all

the

anchors

of

the

list

i

in

the

generalized

knapsack.

The

group

for

agent

l

contains

a

single

element

that

represents

the

interval

−uj

and

the

associated

unit-price

pj

This

interval

represents

the

excess

number

of

units

that

can

be

taken

from

agent

l

in

iKnapsack(

j),

in

addition

to

uj

which

has

already

been

committed.

In

any

other

group,

we

can

choose

at

most

one

anchor.

The

following

pseudo-code

describes

our

algorithm

for

this

restriction

of

the

generalized

knapsack

problem.

U

is

the

union

of

all

the

tuples

in

n

groups,

including

a

tuple

t

for

agent

l.

The

size

of

this

special

tuple

is

defined

as

uj

and

the

cost

is

defined

as

pj

l

−uj

R

is

the

number

of

units

that

remain

to

be

acquired.

S

is

the

set

of

tuples

accepted

in

the

current

tentative

solution.

Best

is

the

best

solution

found

so

far.

Variable

Skip

is

only

used

in

the

proof

of

correctness.

Algorithm

Greedy(

j)

Sort

all

tuples

of

U

in

the

ascending

order

of

unit

price;

in

case

of

ties,

sort

in

ascending

order

of

unit

quantities.

Set

mark(i)

for

all

lists

i

n.

Initialize

R

M

uj

S

Best

Skip

Scan

the

tuples

in

U

in

the

sorted

order.

Suppose

the

next

tuple

is

tk

i

i.e.

the

kth

anchor

from

agent

i.

If

mark(i)

ignore

this

tuple;

otherwise

do

the

following

steps:

if

size(tk

i

R

and

i

return

min

{cost(S)

Rpj

cost(Best)};

if

size(tk

i

R

and

cost(tk

i

cost(S)

return

min

{cost(S)

cost(tk

i

cost(Best)};

if

size(tk

i

R

and

cost(tk

i

cost(S)

Add

tk

i

to

Skip;

Set

Best

to

S

{tk

i

if

cost

improves;

if

size(tk

i

R

then

add

tk

i

to

S;

mark(i)

subtract

size(tk

i

from

R.

The

approximation

algorithm

is

very

similar

to

the

approximation

algorithm

for

knapsack.

Since

we

wish

to

minimize

the

total

cost,

we

consider

the

tuples

in

order

of

increasing

per

unit

cost.

If

the

size

of

tuple

tk

i

is

smaller

than

R,

then

we

add

it

to

S,

update

R,

and

delete

from

U

all

the

tuples

that

belong

to

the

same

group

as

tk

i

If

size(tk

i

is

greater

than

R,

then

S

along

with

tk

i

forms

a

feasible

solution.

However,

this

solution

can

be

far

from

optimal

if

the

size

of

tk

i

is

much

larger

than

R.

If

total

cost

of

S

and

tk

i

is

smaller

than

the

current

best

solution,

we

update

Best.

One

exception

to

this

rule

is

the

tuple

t

Since

this

tuple

can

be

taken

fractionally,

we

update

Best

if

the

sum

of

S"s

cost

and

fractional

cost

of

t

is

an

improvement.

The

algorithm

terminates

in

either

of

the

first

two

cases,

or

when

all

tuples

are

scanned.

In

particular,

it

terminates

whenever

we

find

a

tk

i

such

that

size(tk

i

is

greater

than

R

but

cost(tk

i

is

less

than

cost(S),

or

when

we

reach

the

tuple

representing

agent

l

and

it

gives

a

feasible

solution.

LEMMA

Suppose

A∗

is

an

optimal

solution

of

the

generalized

knapsack,

and

suppose

that

element

(l,

j)

is

midrange

in

the

optimal

solution.

Then,

the

cost

V

(l,

j),

returned

by

Greedy(

j),

satisfies:

V

j)

cost(tj

PROOF.

Let

V

j)

be

the

value

returned

by

Greedy(

j)

and

let

V

j)

be

an

optimal

solution

for

iKnapsack(

j).

Consider

the

set

Skip

at

the

termination

of

Greedy(

j).

There

are

two

cases

to

consider:

either

some

tuple

t

Skip

is

also

in

V

j),

or

no

tuple

in

Skip

is

in

V

j).

In

the

first

case,

let

St

be

the

tentative

solution

S

at

the

time

t

was

added

to

Skip.

Because

t

Skip

then

size(t)

R,

and

St

together

with

t

forms

a

feasible

solution,

and

we

have:

V

j)

cost(Best)

cost(St)

cost(t).

Again,

because

t

Skip

then

cost(t)

cost(St),

and

we

have

V

j)

On

the

other

hand,

since

t

is

included

in

V

j),

we

have

V

j)

cost(t).

These

two

inequalities

imply

the

desired

bound:

V

j)

V

j)

j).

In

the

second

case,

imagine

a

modified

instance

of

iKnapsack(

j),

which

excludes

all

the

tuples

of

the

set

Skip.

Since

of

these

tuples

were

included

in

V

j),

the

optimal

solution

for

the

modified

problem

should

be

the

same

as

the

one

for

the

original.

Suppose

our

approximation

algorithm

returns

the

value

V

j)

for

this

modified

instance.

Let

t

be

the

last

tuple

considered

by

the

approximation

algorithm

before

termination

on

the

modified

instance,

and

let

St

be

the

corresponding

tentative

solution

set

in

that

step.

Since

we

consider

tuples

in

order

of

increasing

per

unit

price,

and

of

the

tuples

are

going

to

be

placed

in

the

set

Skip,

we

must

have

cost(St

V

j)

because

St

is

the

optimal

way

to

obtain

size(St

We

also

have

cost(t

cost(St

and

the

following

inequalities:

V

j)

V

j)

cost(St

cost(t

j)

The

inequality

V

j)

V

j)

follows

from

the

fact

that

a

tuple

in

the

Skip

list

can

only

affect

the

Best

but

not

the

tentative

solutions.

Therefore,

dropping

the

tuples

in

the

set

Skip

can

only

make

the

solution

worse.

The

above

argument

has

shown

that

the

value

returned

by

Greedy(

j)

is

within

a

factor

of

the

optimal

solution

for

iKnapsack(

j).

We

now

show

that

the

value

V

j)

plus

cost(tj

is

a

of

the

original

generalized

knapsack

problem.

Let

A∗

be

an

optimal

solution

of

the

generalized

knapsack,

and

suppose

that

element

xj

is

midrange.

Let

x−

to

be

set

of

the

remaining

elements,

either

zero

or

anchors,

in

this

solution.

Furthermore,

define

x

xj

uj

Thus,

cost(A∗

cost(xl)

cost(tj

l

cost(x−l)

It

is

easy

to

see

that

(x−

x

is

an

optimal

solution

for

iKnapsack(

j).

Since

V

j)

is

a

for

this

optimal

solution,

we

have

the

following

inequalities:

V

j)

cost(tj

cost(tj

cost(x−

cost(tj

cost(x−

This

completes

the

proof

of

Lemma

It

is

easy

to

see

that,

after

an

initial

sorting

of

the

tuples

in

U,

the

algorithm

Greedy(

j)

takes

O(n)

time.

We

have

our

first

polynomial

approximation

algorithm.

THEOREM

A

of

the

generalized

knapsack

problem

can

be

found

in

time

where

n

is

number

of

item

lists

(each

of

constant

length).

PROOF.

We

run

the

algorithm

Greedy(

j)

once

for

each

tuple

(l,

j)

as

a

candidate

for

midrange.

There

are

O(n)

tuples,

and

it

suffices

to

sort

them

once,

the

total

cost

of

the

algorithm

is

By

Lemma

there

is

an

optimal

solution

with

at

most

one

midrange

element,

so

our

algorithm

will

find

a

as

claimed.

The

dependence

on

the

number

of

pieces

is

also

polynomial:

if

each

bid

has

a

maximum

of

c

pieces,

then

the

running

time

is

An

Approximation

Scheme

We

now

use

the

algorithm

presented

in

the

preceding

section

to

develop

a

fully

polynomial

approximation

(FPTAS)

for

the

generalized

knapsack

problem.

The

high

level

idea

is

fairly

standard,

but

the

details

require

technical

care.

We

use

a

dynamic

programming

algorithm

to

solve

iKnapsack(

j)

for

each

possible

midrange

element,

with

the

algorithm

providing

an

upper

bound

on

the

value

of

the

solution

and

enabling

the

use

of

scaling

on

the

cost

dimension

of

the

dynamic

programming

(DP)

table.

Consider,

for

example,

the

case

that

the

midrange

element

is

x

which

falls

in

the

range

[uj

In

our

FPTAS,

rather

than

using

a

greedy

approximation

algorithm

to

solve

iKnapsack(

j),

we

construct

a

dynamic

programming

table

to

compute

the

minimum

cost

at

which

at

least

M

units

can

be

obtained

using

the

remaining

n

lists

in

the

generalized

knapsack.

Suppose

G[i,

r]

denotes

the

maximum

number

of

units

that

can

be

obtained

at

cost

at

most

r

using

only

the

first

i

lists

in

the

generalized

knapsack.

Then,

the

following

recurrence

relation

describes

how

to

construct

the

dynamic

programming

table:

r]

G[i,

r]

max

G[i

r]

max

j∈β(i,r)

{G[i

r

cost(tj

i

uj

i

µ

where

β(i,

r)

{j

j

mi,

cost(tj

i

r},

is

the

set

of

anchors

for

agent

i.

As

convention,

agent

i

will

index

the

row,

and

cost

r

will

index

the

column.

This

dynamic

programming

algorithm

is

only

pseudo-polynomial,

since

the

number

of

column

in

the

dynamic

programming

table

depends

upon

the

total

cost.

However,

we

can

convert

it

into

a

FPTAS

by

scaling

the

cost

dimension.

Let

A

denote

the

to

the

generalized

knapsack

problem,

with

total

cost,

cost(A).

Let

ε

denote

the

desired

approximation

factor.

We

compute

the

scaled

cost

of

a

tuple

tj

i

denoted

scost(tj

i

as

scost(tj

i

n

cost(tj

i

εcost(A)

This

scaling

improves

the

running

time

of

the

algorithm

because

the

number

of

columns

in

the

modified

table

is

at

most

n

ε

and

independent

of

the

total

cost.

However,

the

computed

solution

might

not

be

an

optimal

solution

for

the

original

problem.

We

show

that

the

error

introduced

is

within

a

factor

of

ε

of

the

optimal

solution.

As

a

prelude

to

our

approximation

guarantee,

we

first

show

that

if

two

different

solutions

to

the

iKnapsack

problem

have

equal

scaled

cost,

then

their

original

(unscaled)

costs

cannot

differ

by

more

than

εcost(A).

LEMMA

Let

x

and

y

be

two

distinct

feasible

solutions

of

iKnapsack(

j),

excluding

their

midrange

elements.

If

x

and

y

have

equal

scaled

costs,

then

their

unscaled

costs

cannot

differ

by

more

than

εcost(A).

PROOF.

Let

Ix

and

Iy,

respectively,

denote

the

indicator

functions

associated

with

the

anchor

vectors

x

and

y-there

is

in

position

Ix[i,

k]

if

the

xk

i

Since

x

and

y

has

equal

scaled

cost,

i=

k

scost(tk

i

)Ix[i,

k]

i=

k

scost(tk

i

)Iy[i,

k]

However,

by

the

scaled

costs

satisfy

the

following

inequalities:

(scost(tk

i

n

cost(tk

i

scost(tk

i

)εcost(A)

n

Substituting

the

upper-bound

on

scaled

cost

from

for

cost(x),

the

lower-bound

on

scaled

cost

from

for

cost(y),

and

using

equality

to

simplify,

we

have:

cost(x)

cost(y)

εcost(A)

n

i=

k

Iy[i,

k]

εcost(A),

The

last

inequality

uses

the

fact

that

at

most

n

components

of

an

indicator

vector

are

non-zero;

that

is,

any

feasible

solution

contains

at

most

n

tuples.

Finally,

given

the

dynamic

programming

table

for

iKnapsack(

j),

we

consider

all

the

entries

in

the

last

row

of

this

table,

r].

These

entries

correspond

to

optimal

solutions

with

all

agents

except

l,

for

different

levels

of

cost.

In

particular,

we

consider

the

entries

that

provide

at

least

M

units.

Together

with

a

contribution

from

agent

l,

we

choose

the

entry

in

this

set

that

minimizes

the

total

cost,

defined

as

follows:

cost(G[n

r])

max

{uj

M

G[n

r]}pj

where

cost()

is

the

original,

unscaled

cost

associated

with

entry

r].

It

is

worth

noting,

that

unlike

the

scheme

for

iKnapsack(

j),

the

value

computed

with

this

FPTAS

includes

the

cost

to

acquire

uj

l

units

from

l.

The

following

lemma

shows

that

we

achieve

a

LEMMA

Suppose

A∗

is

an

optimal

solution

of

the

generalized

knapsack

problem,

and

suppose

that

element

(l,

j)

is

midrange

in

the

optimal

solution.

Then,

the

solution

A(l,

j)

from

running

the

scaled

dynamic-programming

algorithm

on

iKnapsack(

j)

satisfies

cost(A(l,

j))

PROOF.

Let

x−

denote

the

vector

of

the

elements

in

solution

A∗

without

element

l.

Then,

by

definition,

cost(A∗

cost(x−

pj

xj

Let

r

scost(x−

be

the

scaled

cost

associated

with

the

vector

x−

Now

consider

the

dynamic

programming

table

constructed

for

iKnapsack(

j),

and

consider

its

entry

G[n

r].

Let

A

denote

the

to

the

generalized

knapsack

problem,

and

A(l,

j)

denote

the

solution

from

the

dynamic-programming

algorithm.

Suppose

y−

is

the

solution

associated

with

this

entry

in

our

dynamic

program;

the

components

of

the

vector

y−

are

the

quantities

from

different

lists.

Since

both

x−

and

y−

have

equal

scaled

costs,

by

Lemma

their

unscaled

costs

are

within

εcost(A)

of

each

other;

that

is,

cost(y−

cost(x−

εcost(A).

Now,

define

yj

max{uj

M

Èi=

Èj

yj

i

this

is

the

contribution

needed

from

to

make

(y−

yj

a

feasible

solution.

Among

all

the

equal

cost

solutions,

our

dynamic

programming

tables

chooses

the

one

with

maximum

units.

Therefore,

i=

j

yj

i

i=

j

xj

i

Therefore,

it

must

be

the

case

that

yj

xj

Because

(yj

y−

is

also

a

feasible

solution,

if

our

algorithm

returns

a

solution

with

cost

cost(A(l,

j)),

then

we

must

have

cost(A(l,

j))

cost(y−

pj

yj

cost(x−

εcost(A)

pj

xj

where

we

use

the

fact

that

cost(A)

Putting

this

together,

our

approximation

scheme

for

the

generalized

knapsack

problem

will

iterate

the

scheme

described

above

for

each

choice

of

the

midrange

element

(l,

j),

and

choose

the

best

solution

from

among

these

O(n)

solutions.

For

a

given

midrange,

the

most

expensive

step

in

the

algorithm

is

the

construction

of

dynamic

programming

table,

which

can

be

done

in

/ε)

time

assuming

constant

intervals

per

list.

Thus,

we

have

the

following

result.

THEOREM

We

can

compute

an

ε)

approximation

to

the

solution

of

a

generalized

knapsack

problem

in

worst-case

time

/ε).

The

dependence

on

the

number

of

pieces

is

also

polynomial:

if

each

bid

has

a

maximum

of

c

pieces,

then

the

running

time

can

be

derived

by

substituting

cn

for

each

occurrence

of

n.

COMPUTING

VCG

PAYMENTS

We

now

consider

the

related

problem

of

computing

the

VCG

payments

for

all

the

agents.

A

naive

approach

requires

solving

the

allocation

problem

n

times,

removing

each

agent

in

turn.

In

this

section,

we

show

that

our

approximation

scheme

for

the

generalized

knapsack

can

be

extended

to

determine

all

n

payments

in

total

time

O(αT

log(αn/ε)),

where

C(I\i)/C(I)

α,

for

a

constant

upper

bound,

α,

and

T

is

the

complexity

of

solving

the

allocation

problem

once.

This

α-bound

can

be

justified

as

a

no

monopoly

condition,

because

it

bounds

the

marginal

value

that

a

single

buyer

brings

to

the

auction.

Similarly,

in

the

reverse

variation

we

can

compute

the

VCG

payments

to

each

seller

in

time

O(αT

log(αn/ε)),

where

α

bounds

the

ratio

C(I\

i)/C(I)

for

all

i.

Our

overall

strategy

will

be

to

build

two

dynamic

programming

tables,

forward

and

backward,

for

each

midrange

element

(l,

j)

once.

The

forward

table

is

built

by

considering

the

agents

in

the

order

of

their

indices,

where

as

the

backward

table

is

built

by

considering

them

in

the

reverse

order.

The

optimal

solution

corresponding

to

C(I

i)

can

be

broken

into

two

parts:

one

corresponding

to

first

(i

agents

and

the

other

corresponding

to

last

(n

i)

agents.

As

the

(i

row

of

the

forward

table

corresponds

to

the

sellers

with

first

indices,

an

approximation

to

the

first

part

will

be

contained

in

(i

row

of

the

forward

table.

Similarly,

(n−

i)th

row

of

the

backward

table

will

contain

an

approximation

for

the

second

part.

We

first

present

a

simple

but

an

inefficient

way

of

computing

the

approximate

value

of

C(I

i),

which

illustrates

the

main

idea

of

our

algorithm.

Then

we

present

an

improved

scheme,

which

uses

the

fact

that

the

elements

in

the

rows

are

sorted,

to

compute

the

approximate

value

more

efficiently.

In

the

following,

we

concentrate

on

computing

an

allocation

with

xj

being

midrange,

and

some

agent

i

l

removed.

This

will

be

a

component

in

computing

an

approximation

to

C(I

i),

the

value

of

the

solution

to

the

generalized

knapsack

without

bids

from

agent

i.

We

begin

with

the

simple

scheme.

A

Simple

Approximation

Scheme

We

implement

the

scaled

dynamic

programming

algorithm

for

iKnapsack(

j)

with

two

alternate

orderings

over

the

other

sellers,

k

l,

one

with

sellers

ordered

n,

and

one

with

sellers

ordered

n,

n

We

call

the

first

table

the

forward

table,

and

denote

it

F

and

the

second

table

the

backward

table,

and

denote

it

Bl.

The

subscript

reminds

us

that

the

agent

is

In

building

these

tables,

we

use

the

same

scaling

factor

as

before;

namely,

the

cost

of

a

tuple

tj

i

is

scaled

as

follows:

scost(tj

i

ncost(tj

i

εcost(A)

where

cost(A)

is

the

upper

bound

on

C(I),

given

by

our

scheme.

In

this

case,

because

C(I

i)

can

be

α

times

C(I),

the

scaled

value

of

C(I

i)

can

be

at

most

nα/ε.

Therefore,

the

cost

dimension

of

our

dynamic

program"s

table

will

be

nα/ε.

FlTable

F

m

g

m

B

(n−i)

n−i

lh

Table

Bl

Figure

Computing

VCG

payments.

m

nα

ε

Now,

suppose

we

want

to

compute

a

)-approximation

to

the

generalized

knapsack

problem

restricted

to

element

(l,

j)

midrange,

and

further

restricted

to

remove

bids

from

some

seller

i

l.

Call

this

problem

iKnapsack−i

j).

Recall

that

the

ith

row

of

our

DP

table

stores

the

best

solution

possible

using

only

the

first

i

agents

excluding

agent

l,

all

of

them

either

cleared

at

zero,

or

on

anchors.

These

first

i

agents

are

a

different

subset

of

agents

in

the

forward

and

the

backward

tables.

By

carefully

combining

one

row

of

Fl

with

one

row

of

Bl

we

can

compute

an

approximation

to

iKnapsack−i

j).

We

consider

the

row

of

Fl

that

corresponds

to

solutions

constructed

from

agents

i

skipping

agent

l.

We

consider

the

row

of

Bl

that

corresponds

to

solutions

constructed

from

agents

n},

again

skipping

agent

l.

The

rows

are

labeled

Fl(i

and

Bl(n

i)

The

scaled

costs

for

acquiring

these

units

are

the

column

indices

for

these

entries.

To

solve

iKnapsack−i

j)

we

choose

one

entry

from

row

F

and

one

from

row

B

(n−i)

such

that

their

total

quantity

exceeds

M

and

their

combined

cost

is

minimum

over

all

such

combinations.

Formally,

let

g

Fl(i

and

h

Bl(n

denote

entries

in

each

row,

with

size(g),

size(h),

denoting

the

number

of

units

and

cost(g)

and

cost(h)

denoting

the

unscaled

cost

associated

with

the

entry.

We

compute

the

following,

subject

We

could

label

the

tables

with

both

and

j,

to

indicate

the

jth

tuple

is

forced

to

be

midrange,

but

omit

j

to

avoid

clutter.

To

be

precise,

the

index

of

the

rows

are

(i

and

(n

i)

for

Fl

and

Bl

when

l

i,

and

(i

and

(n

i

respectively,

when

l

i.

to

the

condition

that

g

and

h

satisfy

size(g)

size(h)

M

min

g∈F

(n−i)

Òcost(g)

cost(h)

pj

max{uj

M

size(g)

size(h)}

Ó

LEMMA

Suppose

A−i

is

an

optimal

solution

of

the

generalized

knapsack

problem

without

bids

from

agent

i,

and

suppose

that

element

(l,

j)

is

the

midrange

element

in

the

optimal

solution.

Then,

the

expression

in

Eq.

for

the

restricted

problem

iKnapsack−i

j),

computes

a

ε)-approximation

to

A−i

PROOF.

From

earlier,

we

define

cost(A−i

C(I

i).

We

can

split

the

optimal

solution,

A−i

into

three

disjoint

parts:

xl

corresponds

to

the

midrange

seller,

xi

corresponds

to

first

i

sellers

(skipping

agent

l

if

l

i),

and

x−i

corresponds

to

last

n

i

sellers

(skipping

agent

l

if

l

i).

We

have:

cost(A−i

cost(xi)

cost(x−i)

pj

xj

Let

ri

scost(xi)

and

r−i

scost(x−i).

Let

yi

and

y−i

be

the

solution

vectors

corresponding

to

scaled

cost

ri

and

r−i

in

F

(i

and

B

(n

i),

respectively.

From

Lemma

we

conclude

that,

cost(yi)

cost(y−i)

cost(xi)

cost(x−i)

εcost(A)

where

cost(A)

is

the

upper-bound

on

C(I)

computed

with

the

Among

all

equal

scaled

cost

solutions,

our

dynamic

program

chooses

the

one

with

maximum

units.

Therefore

we

also

have,

(size(yi)

size(xi))

and

(size(y−i)

size(x−i))

where

we

use

shorthand

size(x)

to

denote

total

number

of

units

in

all

tuples

in

x.

Now,

define

yj

l

max(uj

l

M

−size(yi)−size(y−i)).

From

the

preceding

inequalities,

we

have

yj

l

xj

l

Since

(yj

l

yi,

y−i)

is

also

a

feasible

solution

to

the

generalized

knapsack

problem

without

agent

i,

the

value

returned

by

Eq.

is

at

most

cost(yi)

cost(y−i)

pj

l

yj

l

C(I

i)

εcost(A)

C(I

i)

)ε

C(I

i)

i)ε

This

completes

the

proof.

A

naive

implementation

of

this

scheme

will

be

inefficient

because

it

might

check

pairs

of

elements,

for

any

particular

choice

of

(l,

j)

and

choice

of

dropped

agent

i.

In

the

next

section,

we

present

an

efficient

way

to

compute

Eq.

and

eventually

to

compute

the

VCG

payments.

Improved

Approximation

Scheme

Our

improved

approximation

scheme

for

the

winner-determination

problem

without

agent

i

uses

the

fact

that

elements

in

F

(i

and

B

(n

i)

are

sorted;

specifically,

both,

unscaled

cost

and

quantity

(i.e.

size),

increases

from

left

to

right.

As

before,

let

g

and

h

denote

generic

entries

in

F

(i

and

B

(n

i)

respectively.

To

compute

Eq.

we

consider

all

the

tuple

pairs,

and

first

divide

the

tuples

that

satisfy

condition

size(g)

size(h)

M

l

into

two

disjoint

sets.

For

each

set

we

compute

the

best

solution,

and

then

take

the

best

between

the

two

sets.

[case

I:

size(g)

size(h)

M

uj

l

The

problem

reduces

to

min

g∈F

h∈B

(n−i)

Òcost(g)

cost(h)

pj

l

uj

Ó

We

define

a

pair

(g,

h)

to

be

feasible

if

size(g)

size(h)

M

uj

l

Now

to

compute

Eq.

we

do

a

forward

and

backward

walk

on

F

(i

and

B

(n

i)

respectively.

We

start

from

the

smallest

index

of

F

(i

and

move

right,

and

from

the

highest

index

of

B

(n

i)

and

move

left.

Let

(g,

h)

be

the

current

pair.

If

(g,

h)

is

feasible,

we

decrement

B"s

pointer

(that

is,

move

backward)

otherwise

we

increment

F"s

pointer.

The

feasible

pairs

found

during

the

walk

are

used

to

compute

Eq.

The

complexity

of

this

step

is

linear

in

size

of

F

(i

which

is

O(nα/ε).

[case

II:

M

l

size(g)

size(h)

M

uj

l

The

problem

reduces

to

min

g∈F

h∈B

(n−i)

Òcost(g)

cost(h)

pj

l

(M

size(g)

size(h))

Ó

To

compute

the

above

equation,

we

transform

the

above

problem

to

another

problem

using

modified

cost,

which

is

defined

as:

mcost(g)

cost(g)

pj

l

size(g)

mcost(h)

cost(h)

pj

l

size(h)

The

new

problem

is

to

compute

min

g∈F

h∈B

(n−i)

Òmcost(g)

mcost(h)

pj

l

M

Ó

The

modified

cost

simplifies

the

problem,

but

unfortunately

the

elements

in

F

(i

and

B

(n

i)

are

no

longer

sorted

with

respect

to

mcost.

However,

the

elements

are

still

sorted

in

quantity

and

we

use

this

property

to

compute

Eq.

Call

a

pair

(g,

h)

feasible

if

M

l

size(g)

size(h)

M

uj

l

Define

the

feasible

set

of

g

as

the

elements

h

B

(n

i)

that

are

feasible

given

g.

As

the

elements

are

sorted

by

quantity,

the

feasible

set

of

g

is

a

contiguous

subset

of

B

(n

i)

and

shifts

left

as

g

increases.

Begin

End

B

F

l

Figure

The

feasible

set

of

g

defined

on

B

(n

i),

is

when

M

l

and

M

uj

l

Begin

and

End

represent

the

start

and

end

pointers

to

the

feasible

set.

Therefore,

we

can

compute

Eq.

by

doing

a

forward

and

backward

walk

on

F

(i

and

B

(n

i)

respectively.

We

walk

on

B

(n

i),

starting

from

the

highest

index,

using

two

pointers,

Begin

and

End,

to

indicate

the

start

and

end

of

the

current

feasible

set.

We

maintain

the

feasible

set

as

a

min

heap,

where

the

key

is

modified

cost.

To

update

the

feasible

set,

when

we

increment

F"s

pointer(move

forward),

we

walk

left

on

B,

first

using

End

to

remove

elements

from

feasible

set

which

are

no

longer

feasible

and

then

using

Begin

to

add

new

feasible

elements.

For

a

given

g,

the

only

element

which

we

need

to

consider

in

g"s

feasible

set

is

the

one

with

minimum

modified

cost

which

can

be

computed

in

constant

time

with

the

min

heap.

So,

the

main

complexity

of

the

computation

lies

in

heap

updates.

Since,

any

element

is

added

or

deleted

at

most

once,

there

are

O(nα

ε

heap

updates

and

the

time

complexity

of

this

step

is

O(nα

ε

log

nα

ε

Collecting

the

Pieces

The

algorithm

works

as

follows.

First,

using

the

approximation

algorithm,

we

compute

an

upper

bound

on

C(I).

We

use

this

bound

to

scale

down

the

tuple

costs.

Using

the

scaled

costs,

we

build

the

forward

and

backward

tables

corresponding

to

each

tuple

(l,

j).

The

forward

tables

are

used

to

compute

C(I).

To

compute

C(I

i),

we

iterate

over

all

the

possible

midrange

tuples

and

use

the

corresponding

forward

and

backward

tables

to

compute

the

locally

optimal

solution

using

the

above

scheme.

Among

all

the

locally

optimal

solutions

we

choose

one

with

the

minimum

total

cost.

The

most

expensive

step

in

the

algorithm

is

computation

of

C(I

i).

The

time

complexity

of

this

step

is

α

ε

log

nα

ε

as

we

have

to

iterate

over

all

O(n)

choices

of

tj

l

for

all

l

i,

and

each

time

use

the

above

scheme

to

compute

Eq.

In

the

worst

case,

we

might

need

to

compute

C(I

i)

for

all

n

sellers,

in

which

case

the

final

complexity

of

the

algorithm

will

be

α

ε

log

nα

ε

THEOREM

We

can

compute

an

)-strategyproof

approximation

to

the

VCG

mechanism

in

the

forward

and

reverse

multi-unit

auctions

in

worst-case

time

α

ε

log

nα

ε

It

is

interesting

to

recall

that

T

ε

is

the

time

complexity

of

the

FPTAS

to

the

generalized

knapsack

problem

with

all

agents.

Our

combined

scheme

computes

an

approximation

to

the

complete

VCG

mechanism,

including

payments

to

O(n)

agents,

in

time

complexity

O(T

log(n/ε)),

taking

the

no-monopoly

parameter,

α,

as

a

constant.

Thus,

our

algorithm

performs

much

better

than

the

naive

scheme,

which

computes

the

VCG

payment

for

each

agent

by

solving

a

new

instance

of

generalized

knapsack

problem.

The

speed

up

comes

from

the

way

we

solve

iKnapsack−i

j).

Time

complexity

of

computing

iKnapsack−i

j)

by

creating

a

new

dynamic

programming

table

will

be

ε

but

by

using

the

forward

and

backward

tables,

the

complexity

is

reduced

to

O(n

ε

log

n

ε

We

can

further

improve

the

time

complexity

of

our

algorithm

by

computing

Eq.

more

efficiently.

Currently,

the

algorithm

uses

heap,

which

has

logarithmic

update

time.

In

worst

case,

we

can

have

two

heap

update

operations

for

each

element,

which

makes

the

time

complexity

super

linear.

If

we

can

compute

Eq.

in

linear

time

then

the

complexity

of

computing

the

VCG

payment

will

be

same

as

the

complexity

of

solving

a

single

generalized

knapsack

problem.

CONCLUSIONS

We

presented

a

fully

polynomial-time

approximation

scheme

for

the

single-good

multi-unit

auction

problem,

using

marginal

decreasing

piecewise

constant

bidding

language.

Our

scheme

is

both

approximately

efficient

and

approximately

strategyproof

within

any

specified

factor

ε

As

such

it

is

an

example

of

computationally

tractable

ε-dominance

result,

as

well

as

an

example

of

a

non-trivial

but

approximable

allocation

problem.

It

is

particularly

interesting

that

we

are

able

to

compute

the

payments

to

n

agents

in

a

VCG-based

mechanism

in

worst-case

time

O(T

log

n),

where

T

is

the

time

complexity

to

compute

the

solution

to

a

single

allocation

problem.

REFERENCES

L

M

Ausubel

and

P

R

Milgrom.

Ascending

auctions

with

package

bidding.

Frontiers

of

Theoretical

Economics,

S

Bikchandani,

S

de

Vries,

J

Schummer,

and

R

V

Vohra.

Linear

programming

and

Vickrey

auctions.

Technical

report,

Anderson

Graduate

School

of

Management,

U.C.L.A.,

S

Bikchandani

and

J

M

Ostroy.

The

package

assignment

model.

Journal

of

Economic

Theory,

Forthcoming.

K

Chatterjee

and

W

Samuelson.

Bargaining

under

incomplete

information.

Operations

Research,

E

H

Clarke.

Multipart

pricing

of

public

goods.

Public

Choice,

S

de

Vries

and

R

V

Vohra.

Combinatorial

auctions:

A

survey.

Informs

Journal

on

Computing,

Forthcoming.

M

Eso,

S

Ghosh,

J

R

Kalagnanam,

and

L

Ladanyi.

Bid

evaluation

in

procurement

auctions

with

piece-wise

linear

supply

curves.

Technical

report,

IBM

TJ

Watson

Research

Center,

in

preparation.

J

Feigenbaum

and

S

Shenker.

Distributed

Algorithmic

Mechanism

Design:

Recent

Results

and

Future

Directions.

In

Proceedings

of

the

International

Workshop

on

Discrete

Algorithms

and

Methods

for

Mobile

Computing

and

Communications,

pages

M

R

Garey

and

D

S

Johnson.

Computers

and

Intractability:

A

Guide

to

the

Theory

of

NP-Completeness.

W.H.Freeman

and

Company,

New

York,

G

V

Gens

and

E

V

Levner.

Computational

complexity

of

approximation

algorithms

for

combinatorial

problems.

In

Mathematical

Foundation

of

Computer

Science,

T

Groves.

Incentives

in

teams.

Econometrica,

J

R

Kalagnanam,

A

J

Davenport,

and

H

S

Lee.

Computational

aspects

of

clearing

continuous

call

double

auctions

with

assignment

constraints

and

indivisible

demand.

Electronic

Commerce

Journal,

V

Krishna.

Auction

Theory.

Academic

Press,

V

Krishna

and

M

Perry.

Efficient

mechanism

design.

Technical

report,

Pennsylvania

State

University,

Available

at:

D

Lehmann,

L

I

O"Callaghan,

and

Y

Shoham.

Truth

revelation

in

approximately

efficient

combinatorial

auctions.

JACM,

September

R

B

Myerson.

Optimal

auction

design.

Mathematics

of

Operation

Research,

R

B

Myerson

and

M

A

Satterthwaite.

Efficient

mechanisms

for

bilateral

trading.

Journal

of

Economic

Theory,

N

Nisan

and

A

Ronen.

Computationally

feasible

VCG

mechanisms.

In

ACM-EC,

pages

D

C

Parkes,

J

R

Kalagnanam,

and

M

Eso.

Achieving

budget-balance

with

Vickrey-based

payment

schemes

in

exchanges.

In

IJCAI,

M

H

Rothkopf,

A

Pekeˇc,

and

R

M

Harstad.

Computationally

manageable

combinatorial

auctions.

Management

Science,

J

Schummer.

Almost

dominant

strategy

implementation.

Technical

report,

MEDS

Department,

Kellogg

Graduate

School

of

Management,

W

Vickrey.

Counterspeculation,

auctions,

and

competitive

sealed

tenders.

Journal

of

Finance,

approximately-efficient and approximately strategyproof auction mechanism

single-good multi-unit allocation problem

fully polynomial-time approximation scheme

marginal-decreasing piecewise constant curve

forward auction
reverse auction
equilibrium
bidding language
dynamic programming
approximation algorithm
strategyproof


PackageBLAST: An Adaptive Multi-Policy Grid Service for Biological Sequence Comparison ∗ Marcelo S. Sousa University of Brasilia Campus UNB - ICC Norte, sub-solo Brasilia, Brazil msousa@unb.br Alba Cristina M. A. Melo University of Brasilia Campus UNB - ICC Norte, sub-solo Brasilia, Brazil alves@unb.br ABSTRACT In this paper, we propose an adaptive task allocation framework to perform BLAST searches in a grid environment against sequence database segments. The framework, called PackageBLAST, provides an infrastructure to choose or incorporate task allocation strategies. Furthermore, we propose a mechanism to compute grid nodes execution weight, adapting the chosen allocation policy to the current computational power of the nodes. Our results present very good speedups and also show that no single allocation strategy is able to achieve the lowest execution times for all scenarios. Categories and Subject Descriptors C.2.4 [Distributed Systems]: Distributed Applications; J.3 [Life and Medical Sciences]: Biology and Genetics 1. INTRODUCTION Biological sequence comparison (or sequence alignment) is one of the most important problems in computational biology, given the number and diversity of the sequences and the frequency on which it is needed to be solved daily. SW [14] is an exact algorithm that finds the best local alignment between two sequences of size n in quadratic time and space. In genome projects, the size of the sequences to be compared is constantly increasing, thus an O(n2 ) solution is expensive. For this reason, heuristics like BLAST [3] were proposed to reduce execution time. The popularity of the Internet made possible the interconnection of millions of powerful machines in a global scale. This led to the idea of grid computing, which involves cooperative and secure sharing of non-dedicated and heterogeneous resources that are geographically distributed [5]. Resource scheduling is one of the most important components of a grid system. The choice of the best resources for a particular application is called task allocation, which is an NP-Complete problem. Grid applications usually do not have high communication rates and many of them follow the master/slave model [13]. In order to schedule master/slave applications many task allocation policies were proposed such as Self Scheduling [15] and FAC2 [8]. The choice of the best allocation policy depends on the application access pattern and on the environment in which it runs [13]. In this paper, we propose PackageBLAST, an adaptive multi-policy grid service to run BLAST searches in grids composed by segmented genetic databases. PackageBLAST executes on Globus 3 [4] and, by now, provides five allocation policies. Also, we propose an adaptive mechanism to assign weights to the grid nodes, taking into account their current workload. As far as we know, this is the first grid service that runs BLAST with multiple task policies with a segmented database in a heterogeneous non-dedicated platform. This paper is organized as follows. Section 2 presents the sequence comparison problem and the BLAST algorithm. Section 3 describes allocation policies for grids. Section 4 discusses related work. Section 5 presents the design of PackageBLAST. Experimental results are discussed in section 6. Section 7 concludes the paper. 2. SEQUENCE COMPARISON To compare two sequences, we must find the best alignment, which is to place one sequence above the other making clear the correspondence between similar characters [7]. Given an alignment between two sequences, a score is usually associated for it as follows (figure 1). For each column, we associate, for instance, +1 if the two characters are identical, -1 if the characters are different and -2 if one of them is a space. The score is the sum of all the values and the maximal score is the similarity between the sequences. To compute exact local sequence alignments, [14] proposed an algorithm (SW), based on dynamic programming, with quadratic time and space complexity. Usually, one given biological sequence is compared against thousands or even millions of sequences that compose genetic data banks. By now, there are millions of entries composed of billions of nucleotides at GenBank, which is one of the most important public gene repositories. Due to the 156 G A C G G A T T A G G A T C G G A A T A G +1 +1 −2 +1 +1 +1 +1 −1 +1 +1 +1 Σ = 6 Figure 1: Example of an alignment with score 6 current growth rate, these databases will soon achieve terabytes. In this scenario, the use of exact methods such as SW is prohibitive. For this reason, faster heuristic methods are proposed which do not guarantee that the best alignment will be produced. Usually, these heuristic methods are evaluated using the concepts of sensitivity and sensibility. Sensitivity is the rate at which the method fails to identify similar sequences whereas sensibility is the rate at which the method identifies sequences that are not similar [7]. BLAST [1] is the most widely used heuristic method for sequence comparison. 2.1 The BLAST Algorithm BLAST (Basic Local Alignment Tool) [1] is a set of programs used to search DNA and protein databases for similarities between sequences. It is designed to obtain high performance with low impact in terms of sensibility. BLAST provides programs to compare many combinations of query and database sequence types (table 1). Table 1: Some of the BLAST family programs Program Database Query Translation BLASTN Nucleotide Nucleotide None BLASTP Protein Protein None BLASTX Protein Nucleotide Query The first version of BLAST searched for local similarities without taking spaces (gaps) into account. In 1996-1997, two gapped versions of BLAST emerged: NCBI-BLAST [3] and WU-BLAST [6]. Basically, the algorithm proceeds in three steps: seeding, extension and evaluation. In the seeding step, a query sequence is split in portions called words of size W. These words are matched to database sequences and used as alignment seeds if their scores are higher than a threshold T. In the extension step, alignments are generated from seeds. A parameter X maintains the recent alignment history and controls this step. Once seeds are extended, the last step begins. The alignments are evaluated to determine if they are statistically significant. The significant ones are termed HSPs (High-scoring Segment Pairs). A new parameter, S, is used to sort alignments. The combination of parameters W, T, X and S is used to determine the sensitivity and speed of BLAST searches. 3. TASK ALLOCATION FOR GRIDS 3.1 Grid Computing Grid Computing was initially developed to enable resource sharing between scientific institutions who needed to share data, software and computational power. The Globus Toolkit [4] emerged as an open source project and quickly became a de facto standard for grid computing infrastructure. Globus implements a set of protocols, APIs and services used by hundreds of grid applications all over the world. In 2002, the Open Grid Services Architecture (OGSA) was introduced by the Global Grid Forum (GGF) to expand standardization. OGSA provided a new architecture for grid applications based on web services in order to achieve interoperability using industry standards. Many OGSA architecture implementations were developed, including one for Globus. The work carried out in this paper is deployed on a grid based on Globus (GT3). Usually, grid applications are modelled as master/slave, where one problem is divided in many independent work units (tasks) of smaller size that can be distributed to slave nodes for parallel processing. A very important problem to be solved in this context is task allocation. The task allocation problem consists of assigning tasks to processors in order to maximize system performance [13]. In this problem, it is assumed that no precedence relations exist among the tasks. 3.2 Task Allocation Strategies Given a master/slave application composed by a master m and S slaves, the allocation function allocate(m, si, N, S) determines how many tasks out of N must be assigned to a slave si (equation 1), where A(N, S) represents an allocation policy. WeightFactor(m, si, S) was defined by [13] (equation 2) and provides weights for each slave si, based on its statically known processing rate (WorkerRate). allocate(m, si, N, S) = A(N, S) ∗ W eightF actor(m, si, S) (1) W eightF actor(m, si, S) = P ∗ W orkerRate(m, si) P i=1 W orkerRate(m, si) (2) The following subsections present some work allocation policies, which are instances A(N, S) of equation 1. 3.3 Fixed (Static Scheduling) The Fixed [13] strategy distributes all work units uniformly to slaves nodes. This strategy is appropriate for homogeneous systems with dedicated resources (equation 3). A(N, S) = N S (3) 3.4 Self Scheduling (SS) Self Scheduling (SS) [15] distributes a single work unit to every slave node (equation 4). A(N, S) = 1, while work units are still left to allocate (4) In SS, the maximum imbalance is limited by the processing time of a work unit in the slowest node. Nevertheless, SS usually demands a lot of communication, since each work unit retrieval requires one interaction with the master. 3.5 Trapezoidal Self Scheduling (TSS) Trapezoidal Self-Scheduling (TSS) [16] allocates work units in groups with a linearly decreasing size. This strategy uses two variables, steps and δ, that represent the total number of allocation steps and the block reduction factor, respectively (equations 5 and 6). steps = 4NS N + 2S (5) 157 δ = N − 2S 2S(steps − 1) (6) TSS calculates the length of the sth block using the difference between the length of the first block and total reduction from the last s − 1 blocks (equation 7). A(s, N, S) = max N 2S − [(s − 1) ∗ δ] , 1 (7) 3.6 Guided Self Scheduling (GSS) Guided Self-Scheduling (GSS) [11] allocates work units in groups whose length decrease exponentially. Its goal is to create a tradeoff between the number of the work units processed and the imbalance in finishing times (equation 8). A(s, N, S) = max N 1 − 1 S s−1 S , 1 , s > 0 (8) 3.7 Factoring (FAC2) FAC2 allocates work units in cycles consisting of S allocation sequences. Equation 9 shows the function that defines the cycle number of an iteration s. In FAC2, half of the remaining work units are allocated in each round (equation 10). round(s) = (s − 1) S + 1 (9) A(s, N, S) = max N S ∗ 2round(s) , 1 (10) 4. RELATED WORK MpiBLAST [2] was proposed for clusters and has two phases. First, the genetic database is segmented. Then, the queries are evenly distributed among the nodes. If the node does not have a database fragment, a local copy is made. A method is proposed that associates data fragments to nodes, trying to minimize the number of copies. BLAST++ [10] groups multiple sequences to reduce the number of database accesses. A master/slave approach is used that allocates the queries to the slaves according to the fixed policy (section 3.3). Each worker executes BLAST++ independently and, finally, the results are collected and combined by the master. GridBlast [9] is a master/slave grid application that uses Globus 2. It distributes sequences among the grid nodes using two allocation policies: FCFS and minmax. Of those, only the last one takes into account the current load and the heterogeneity of the environment. However, to use minmax, the total execution time of each BLAST task must be known. Having decided which sequences will be compared by each node, GridBlast sends the sequences, the executable files and the whole database to the chosen node. When the search finishes, the results are compacted and sent to the master. Grid Blast Toolkit (GBTK) [12] is a web portal to execute BLAST searches in Globus 3. All genetic databases are statically placed on the grid nodes (without replication). GBTK is a master/slave application that receives the sequences and the name of the genetic database. It then verifies if the node that contains the database is available. If so, it is selected. If the node is not available, the less loaded node is chosen and the database is copied to it. Master SlaveSlaveSlave Internet database segment but only part of it is processed in each node The database is replicated in the nodes, Figure 2: PackageBLAST segmentation and distribution mechanism. 5. DESIGN OF PACKAGEBLAST We propose an adaptive task allocation framework which is a grid service to perform BLAST searches against sequence database segments. The framework, called PackageBLAST, provides an infrastructure to choose or incorporate allocation strategies in a master/slave application. We also propose a strategy to compute grid nodes execution weight which distributes work units (database segments) to grid nodes according to their current computational power. 5.1 Database Segmentation and Replication Segmentation consists in the division of a database archive in many portions of smaller size, called segments, that can be processed independently. It enables grid nodes to search smaller parts of a sequence database, reducing the number of disk accesses and hence improving BLAST performance. Also, a single query sequence can be compared against all segments in parallel. Just as in mpiBLAST (section 4), we decided to use database segmentation in PackageBLAST with an NCBI tool called formatdb, which was modified to generate more database segments of smaller size. We opted to replicate the segmented database in every slave grid node to improve data accesses times and to provide a potential for fault tolerance. Figure 2 illustrates this. 5.2 Task Allocation As [13], we think that no allocation policy will produce the best results for every situation. Thus, we propose the use of a framework where many allocation policies can be incorporated. By now, our framework contains five allocation policies: Fixed, SS, GSS, TSS, FAC2, all described in section 3. So, the user can choose or even create the allocation policy which is the most appropriate to his/her environment and his/her BLAST parameters. Besides that, we propose PSS (Package Weighted Adaptive Self-Scheduling), a new strategy that adapts the chosen allocation policy to a grid with local workload. Considering the heterogeneity and dynamic characteristics of the grid, PSS is able to modify the length of the work units during execution, based on average processing time of each node. The expression used for work unit allocation is shown in equation 11, where A(N, P) is the allocation policy for a system with N workload units and P nodes and Φ(m, pi, P) is the weight calculated by PSS. A(N, P) can be a pre-defined allocation policy or a user-defined one. 158 allocate(m, pi, N, P ) = A(N, P ) ∗ Φ(m, pi, P ) (11) To distribute database segments to nodes, the master analyzes periodic slave notifications. The expression used is Φ(m, pi, P) (equation 12), defined as the weighted mean from the last Ω notifications sent by each pi slave node. Φ(m, pi, P ) = P ∗ P i=1 Γ(m,pi,Ω) Γ(m,pi,Ω) P i=1 P i=1 Γ(m,pi,Ω) Γ(m,pi,Ω) (12) Γ(m, pi, Ω) (equation 13) specifies the average computing time of a segment in a node pi, considering the last Ω notifications of TE(m, pi, τ), which is the average computation time of τ work units (database segments) assigned by the master m to a slave pi. At the moment of computation of Γ, if there is not enough notifications of TE, the calculation is done with total k notifications already received. Γ(m, pi, Ω) = min(Ω,k) j=1 T E(m, pi, τ) min(Ω, k) (13) 5.3 PackageBLAST"s General Architecture PackageBLAST was designed as a grid service over Globus 3, based on Web Services and Java. Figure 3 presents the PackageBLAST architecture. BLAST receives MASTER Strategies Allocation Work units Generate Work Units Distribute Reports Generate work units (to slaves)reports searches Figure 3: PackageBLAST architecture. The module Allocation Strategies contains implementations for the pre-defined allocation policies (Fixed, SS, GSS, TSS and FAC2) and also makes possible the creation of new allocation strategies. The module Generate Work Units is the core of the PSS mechanism. It calculates the weight of each slave node and decides how many work units will be assigned to a particular slave node, according to the chosen allocation policy. Distribute Work Units is the module responsible for the communication between the master and slaves nodes. It distributes the work units generated by the previous module and collects the notifications. Finally, the module Generate Reports obtains the intermediary outputs sent by the slave nodes through file transfer and merges them into a single BLAST output report. In general, the following execution flow is executed. The user specifies the sequence to be compared and chooses the allocation strategy. The master node starts execution and waits for slave connections. To start processing, a minimum number of slaves must register into the master node, by calling a master grid service. After receiving connections from the slaves, the master notifies them about their initial segments to compare. The slave processes τ database segments and notifies the master, which uses the last Ω notifications to compute the next allocation block size based on the selected allocation strategy and the weight provided by PSS. Then, the master sends a XML message to the slave informing its new segments to process. This flow continues until all segments are processed. 6. EXPERIMENTAL RESULTS PackageBLAST was evaluated in a 16-node grid testbed, composed by two laboratories, interconnected by a localarea network. Eleven desktops (P01-11) and a notebook (NB) were used in LABPOS and four desktops (L01-04) were used in LAICO (table 2). All grid nodes used Linux with Globus 3.2.1, NCBI BLAST 2.2.10 and Java VM 1.4.2. Table 2: Characteristics of the grid testbed. Node Names CPU Main Memory HD NB 3200 MHz 512 MB 80 GB L01-L03 1700 MHz 256 MB 30 GB L04 350 MHz 160 MB 6 GB P01-P10 1000 MHz 256 MB 20 GB P11 900 MHz 128 MB 20 GB To investigate the performance gains of PackageBLAST, we executed BLASTX in 2, 4, 8 and 16 grid nodes. Each BLAST search compared a 10KBP real DNA sequence against the 1.2GB nr genetic database segmented in 167 parts of 5MB each. Fixed, SS, TSS, GSS and FAC2 allocation strategies were employed in the tests. Execution times for all allocation strategies are presented in table 3. Table 3: Execution times for BLASTX. Strategy 2 nodes 4 nodes 8 nodes 16 nodes FIXED 2037 999 491 252 SS 1112 514 246 134 TSS 1296 570 259 143 GSS 1115 535 250 127 FAC2 1187 514 266 142 Table 4 presents execution times in a single machine and absolute speedups for 2, 4, 8 and 16 nodes, considering the best execution time for a given number of nodes. To calculate the absolute speedups, the BLAST sequential version was executed with the nr unsegmented database. Table 4: Sequential execution times and speedups. Node SeqTime 2 nodes 4 nodes 8 nodes 16 nodes NB 1432 1.29 2.79 5.82 11.28 L01 1585 1.43 3.08 6.44 12.48 P01 1853 1.67 3.61 7.53 14.59 P11 2004 1.80 3.90 8.15 15.78 L04 3810 3.43 7.41 15.49 30.00 PackageBLAST achieved very good speedups. Considering the worst (L04), average (P01) and best (NB) node in the grid, the speedups obtained were superlinear, close to linear and sublinear, respectively. In table 3, it can also be noticed that there is no allocation strategy that always reaches the best execution time. This variation justifies the allocation framework provided. To evaluate PSS, we executed PackageBLAST with 16 grid nodes, introducing local workload in nodes L01, L02, P01 and P02. The load was started simultaneously 30 seconds after the beginning of BLAST and consisted of the 159 execution of formatdb on the nr database. Three scenarios were simulated (table 5): 1) with PSS strategy, but without workload; 2) with PSS strategy and workload (PSS 2x), to use grid environment knowledge obtained in the preceeding iteration; and 3) Execution without PSS and with workload. Table 5: PSS evaluation with local workload. Gain is the comparison of without PSS with PSS 2x Strategy with PSS PSS 2x without PSS Gain Fixed 316 184 393 113.59% SS 186 177 179 1.13% TSS 160 162 171 5.56% GSS 149 159 339 113.21% FAC2 156 165 153 -7.27% As expected, the allocation strategies that assign a large amount of work to the nodes (fixed and GSS) obtained great benefit from using PSS. This is due to the fact that a slow node can easily become a bottleneck in these strategies. TSS also obtained a reduction of 5.56% in its execution time. PSS uses two parameters: τ and Ω (section 5.2). We varied these parameters in order to evaluate the PSS behavior in two scenarios. In both cases, we used a four-node (NB, L01, P01, L04) grid. In the first experiment, a local workload (formatdb) was introduced when the last task of the first TSS allocation starts and was stopped immediately after the processing of one segment. The goal was to evaluate the impact of short-lived local tasks in PSS. In the second case, local workload was introduced at the same time of the previous case, but continued until the end. The goal was to evaluate long-lived local tasks. Figure 4 presents the gains. Figure 4: Percentual gain obtained by PSS varying τ and Ω parameters. In scenario 1, when a very recent history is considered (τ=1 and Ω=1), PSS tries to adapt to a situation that will shortly disappear. For τ=5 and Ω=4, PSS takes longer to notice modification and short-lived tasks have low impact. On the other hand, in scenario 2, τ=1,Ω=1 presents better results than τ=5, Ω=4, because it changes weights faster. 7. CONCLUSION In this article, we proposed and evaluated PackageBLAST, an adaptive multi-policy grid service to execute master/slave BLAST searches. PackageBLAST contains a framework where the user can choose or incorporate allocation policies. We also defined a strategy, PSS, that adapts the chosen policy to a heterogeneous non-dedicated grid environment. The results collected by running PackageBLAST with 5 allocation policies in a grid testbed were very good. In order to compare a 10KBP real DNA sequence against the nr genetic database, we were able to reduce execution time from 30.88 min to 2.11 min. Also, we showed that, in our testbed, there is no allocation policy that always achieves the best performance and that makes evident the importance of providing multiple policies. Moreover, we showed that the introduction of PSS led to very good performance gains for some policies. As future work, we intend to run PackageBLAST in a geographically dispersed grid, to evaluate the impact of high network latencies in the allocation policies and in PSS. Also, we intend to provide support for genomic database synchronization and dynamic join/leave operations for slaves. 8. REFERENCES [1] S. F. Altschul, W. Gish, W. Miller, E. W. Myers, and D. J. Lipman. A basic local alignment search tool. Journal of Molecular Biology, 215:403-410, 1990. [2] A. Darling, L. Carey, and W. Feng. The design, implementation, and evaluation of mpiblast. 4th International Conference on Linux Clusters, 2003. [3] S. F. A. et al. Gapped blast and psi-blast: a new generation of protein database search programs. Nucleic Acids Research, 25(17):3389-3402, 1997. [4] I. Foster and C. Kesselman. Globus: A metacomputing infrastructure toolkit. International Journal of Supercomputer Applications, 11(2):115-128, 1997. [5] I. Foster and C. Kesselman. The Grid: Blueprint of a Future Computing Infrastructure. Morgan-Kauffman, 1999. [6] W. Gish. Washington university blast. http://blast.wustl.edu, 1996-2002. [7] D. Gusfield. Algorithms on Strings, Trees and Sequences. Cambridge University Press, 1997. [8] S. F. Hummel, E. Schonberg, and L. E. Flynn. Factoring: A method for scheduling parallel loops. Communications of the ACM, 35(8):90-101, 1992. [9] A. Krishnan. Gridblast: High throughput blast on the grid. Symposium on Biocomputing, January 2003. [10] D. Peng., W. Yan, and Z. Lei. Parallelization of blast++. Technical report, Singapore-MIT, 2004. [11] C. D. Polychronopoulos and D. J. Kuck. Guided self-scheduling: A practical scheduling scheme for parallel supercomputers. IEEE Transactions on Computers, 36(12):1425-1439, Dec. 1987. [12] M. K. Satish and R. R. Joshi. Gbtk: A toolkit for grid implementation of blast. 7th International Conference HPCAsia, pages 378-382, 2004. [13] G. Shao. Adaptive Scheduling of Master/Worker Applications on Distributed Computational Resources. PhD thesis, Univ. California at San Diego, 2001. [14] T. Smith and M. Waterman. Identification of common molecular subsequences. J. Mol. Biol., 147:195-197, 1981. [15] P. Tang and P. C. Yew. Processor self-scheduling for multiple nested parallel loops. In Int. Conf. on Parallel Processing (ICPP), pages 528-535, 1986. [16] T. H. Tzen and L. M. Ni. Trapezoidal self-scheduling: A practical scheme for parallel compilers. IEEE Transactions on Parallel and Distributed Systems, 4(1):87-98, Jan. 1993. 160

B 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 B I O O O O O O O B I O O O O O O O B 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 B I I 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 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 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 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 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 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 B I O O O B I 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 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 B I 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 O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O 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 B O O O O B I 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 O O O O O O O O O O O O O O O O O O O O O O O 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 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 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 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 B 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 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 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 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 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 B 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 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 B 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 B O O O O O O B O O O B O O O B I O O O O O O O O O O B O O O O O B O O O O O O O O O O B O B O O O B B 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 O O O O O 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 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 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 B 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 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 B 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 B O O O O O O O O O B I 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 B 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 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

package weighted adaptive self-scheduling

biological sequence comparison
task allocation
blast search
packageblast
grid computing
computational biology
grid environment
pss