APPROXIMATING THE DISCRETE RESOURCE SHARING SCHEDULING PROBLEM

July 20, 2009 17:36 WSPC/INSTRUCTION FILE IJFCS˙format˙ok

International Journal of Foundations of Computer Sciencec© World Scientific Publishing Company

Approximating the Discrete Resource Sharing Scheduling Problem

Marin Bougeret ∗, Pierre-Francois Dutot, Alfredo Goldman †, Yanik Ngoko ‡and Denis Trystram

LIG, Grenoble University, 51 avnue J. Kuntzmann

38330 Montbonnot, France

[email protected]

The goal of this work is to study the portfolio problem which consists in finding agood combination of multiple heuristics given a set of a problem instances to solve. Weare interested in a parallel context where the resources are assumed to be discrete and

homogeneous, and where it is not possible to allocate a same resource to more than oneheuristic. The objective is to minimize the average completion time over the whole set ofinstances. We extend our previous work on this problem. We provide a complexity result,

we generalize our previous approximation schemes and we improve them using the guessapproximation technique. Experimental results are also provided using a benchmark ofinstances on SAT solvers.

Keywords: resource allocation; combining algorithms; approximation schemes; oracle-guess approximation; SAT solver.

1. Introduction

1.1. Description of the Portfolio problem

We are interested in this work in solving hard computational problems like the

satisfiability problem SAT [10]. It is well-established that a single algorithm cannot

solve efficiently all the instances of such problems. In most cases, the algorithms

are characterized by the great variability of their execution time depending on the

considered instances. Thus, a good effective solution is to consider several heuristics

and combine them in such a way to improve the mean execution time when solving

a large set of instances. In this paper, we are interested in designing adequate

combination schemes.

The suggested solution is based on the portfolio problem, introduced in the field

of finance many years ago [13]. This problem can be informally recalled as follows:

∗Marin Bougeret has a PhD grant from DGA-CNRS†Alfredo Goldman has been partially supported by the MINALOGIC project SCEPTRE funded

by Region Rhne-Alpes‡Yanik is sponsored by EGIDE

1


2 Marin Bougeret, Pierre-Francois Dutot, Alfredo Goldman, Yanik Ngoko and Denis Trystram

given a set of opportunities, an amount of possible investments on the set of oppor-

tunities and the payoff obtained when investing an amount on each opportunity,

what is the best amount of investment to make on each opportunity in order to

maximize the sum of the payoffs? Using the vocabulary of Computer Science, we

assume that there exists a benchmark composed of a finite set of instances and some

heuristics which solve these instances. The expected execution times of heuristics on

all the instances is known. The objective is to determine the best possible resource

allocation for the heuristics in order to minimize the mean execution time of the set

of instances. The execution time of an instance given a resource allocation is taken

here as the shortest execution time of a heuristic when executing simultaneously all

the heuristics on this instance.

This formulation of the problem as a portfolio is motivated by the fact that we

may not know which is the best suited heuristic to solve an instance before actually

solving it. The interest of this sharing model is that in practice if the benchmark of

instances is representative over the set to be solved, we can expect a better mean

execution time than using only one heuristic.

1.2. Related works

There exist many studies focusing on the construction of automated heuristic selec-

tion process. For a given problem, the approaches usually proceed first by identifying

the set of features which characterize its instances. A matching is then built between

types of instances and heuristics in order to determine an efficient heuristic for any

instance.

An et al. [2], for example, introduce a generic framework for heuristic selection

in a parallel context and apply it to several classical problems including sorting

and parallel reductions. Weerawarana et al. [20] suggest a model for the heuristics

selection in the case of the resolution of partial differential equations. The SALSA

project (Self Adapting Large-scale Solver Architecture) uses statistical techniques

for solver selection [7]. Bhowmick et al. [3] study the construction of a selection

process for solving linear systems. The construction of automated selection pro-

cess requires the identification of a representative set of features. This can be very

difficult depending on the targeted problems [7].

There exist other alternative works based on heuristic portfolio that can be used

in these cases. A portfolio of heuristics is a collection of different algorithms (or

algorithms with different parameters) running in an interleaved scheme. In [11, 12],

the authors have demonstrated the interest to use heuristic portfolio on randomized

heuristics. The concurrent use of heuristics for solving an instance has also been

suggested in [6, 19] with the concept of asynchronous team. Streeter et al. [18]

studied how to interleave the execution of various heuristics in order to reduce the

execution time of a set of instances.

Sayag et al. [14] have also studied a related problem, namely the time switching

problem. This problem considers a finite set of instances and assume a finite set of


Approximating the Discrete Resource Sharing Scheduling Problem 3

interruptible heuristics. To solve instances, the execution of the various heuristics

are interleaved in a fixed pattern of time intervals. The execution ends as soon as one

heuristic solves the current instance. As previously, the goal in the task switching

problem is to find a schedule which minimizes the mean execution time on the set

of instances. This approach is interesting in a single resource problem and has also

been studied by Streeter et al. [18]. Sayag et al. [14] proved that to each resource

sharing schedule corresponds a time switching with a lower execution time, which

means that if there is no overhead on context switching, it is always better to use

time slicing on the heuristics on the whole resources instead of applying resource

sharing. Even if the time switching approach produces theoretically schedules with

constant approximation ratio, it assumes that the heuristics can be interrupted at

any moment. However, all the interrupted states have to be stored, leading to a

prohibitive memory cost on multiple resources.

Let us notice also that in several cases, giving more resources to a heuristic

does not have a positive impact on its execution. This is especially true when using

heuristics that are hard to parallelize, like those involving a large number of irregular

memory accesses and communications [21]. That is why we focus on the discrete

version of the resource sharing scheduling problem (denoted by RSSP) instead of

time switching as introduced in [14].

To the best of our knowledge, there are mainly two papers about the RSSP

that are closely related to our work. Sayag et al.[14] address the RSSP in the

continuous version (the output is a fraction of the available resources allocated to

each heuristic), using a linearity assumption (meaning that the cost for solving

an instance with only one resource is x times the cost with x resources). In our

previous work [4] is studied a discrete version (the output is the number of resources

allocated to each heuristic) of the RSSP (denoted by dRSSP), using also a linearity

assumption. Notice that we rather study a restricted version of the dRSSP (denoted

by r-dRSSP) where every solution must allocate at least one processor to every

heuristic, given that the dRSSP has no constant ratio polynomial approximation

algorithm (unless P = NP ) [4].

1.3. Contributions and organization of the paper

In this work, we study the r-dRSSP without the linear assumption. More precisely,

given any heuristic hi, any instance Ij and any number of allocated resources x ∈

{1, . . . ,m}, we only assume that C(hi, Ij , s) (the cost for solving Ij with hi deployed

on s resources) verify 1 ≤C(hi,Ij ,s)

C(hi,Ij ,λs) ≤ λ,∀λ ≥ 1. This reasonable assumption means

that we handle any instance where the speedup is non “super linear”.

A preliminary version (for the linear r-dRSSP) was published in the APDCM

workshop [4]. The dRSSP problem is defined in section 2.1. We provide in section 2.2

a proof for the complexity of the linear r-dRSSP (which was still open in [4]). In

section 2.3, a first greedy algorithm is provided to give an insight on the problem.

Oracle-based algorithms are then introduced in section 3.1. We extend in 3.2 and 3.3



the oracle based approximation schemes proposed in [4] to the “non linear” case.

We give in 3.4 a kind of tightness result by proving that the question asked to the

oracle is almost the most “efficient” possible. Then, we improve in section 3.5 these

approximation scheme by applying the guess approximation technique (introduced

and applied to the linear r-dRSSP in [5]). Finally, in section 4 we run experiments

(using instances extracted from actual execution time of heuristics solving the SAT

problem) to evaluate these algorithms.

2. Discrete Resource Sharing Scheduling Problem

2.1. Definition of the problem

discrete Resource Sharing Scheduling Problem (dRSSP)

Instance: A finite set of instances I = {I1, . . . , In}, a finite set of heuristics

H = {h1, . . . , hk}, a set of m identical resources, a cost C(hi, Ij , p) ∈ R+ for each

Ij ∈ I, hi ∈ H and p ∈ {1, . . . ,m}, such that 1 ≤C(hi,Ij ,s)

C(hi,Ij ,λs) ≤ λ,∀λ ≥ 1

Output: An allocation of the m resources S = (S1, . . . , Sk) such that Si ∈ N

and∑k

i=1 Si ≤ m that minimizes∑n

j=1 min1≤i≤k

{C(hi, Ij , Si)|Si > 0}

The idea in this problem is to find an efficient partition of resources to

deploy the set of heuristics on the homogeneous resources. The cost function

( min1≤i≤k

{C(hi, Ij , Si)}) introduced by Sayag et al. [14] and used here, considers that

for each instance, all the different heuristics are executed with the defined share

and then stop their execution when at least one heuristic finds a solution.

In all the paper, the linear cost assumption indicates that the execution

cost is proportional to the number of resources used (C(hi, Ij , p) =C(hi,Ij ,m)m

p ).

We proved in [4] that the dRSSP has no constant ratio polynomial approximation

algorithm (unless P = NP ), even with the linear cost assumption. Thus, we address

in this work a restricted version of the dRSSP (denoted by r-dRSSP) where each

heuristic must use at least one resource.

2.2. Complexity

The NP completeness proof of the linear (non restricted) dRSSP is provided in [4],

using a reduction from the vertex cover problem. However, this proof cannot be

directly adapted to the linear r-dRSSP. Indeed, the gap between the optimal and

non optimal case comes from the fact it is impossible to give one resource to every

“important” heuristic when there is no vertex cover, whereas the new constraint

in r-dRSSP forces any solution to allocate at least one resource to every heuristic.

Thus, we add in the new reduction (still from the vertex cover) some artificial

instances that amortize this new constraint.

Theorem 1. The r-dRSSP is NP hard, with a linear cost function.

Proof. Let us denote by T the threshold value of the r-dRSSP decision prob-

lem. Given any solution S and any subset X ⊂ I, we denote by f(S)|X =



∑

Ij∈X min1≤i≤k

{C(hi, Ij , Si)|Si > 0} the restricted cost of S on X. Being given a

graph G = (V,E), V = {v1, . . . , vk}, k = |V |, |E| = n in which we are looking for a

vertex cover V c ⊆ V of size x, we construct an instance of the r-dRSSP problem as

follows. We define the set of heuristics as H = {h1, . . . , hk} (to each hi corresponds

the vertex vi ∈ V ). The number of resources is m = k + x. Given that any solution

of the dRSSP must allocate at least one resource to each heuristic, the decision

only concerns the x extra resources. We choose I = I ′ ∪ I ′′, with I ′ = {I1, . . . , In}

(to each Ij ∈ I ′ corresponds an edge (vj1 , vj2) ∈ E), and I ′′ = {In+1, . . . , In+k}

(I ′′ forces the solutions to equilibrate the x “extra” resources, which means not

giving more than 2 resources to anybody). Given that we are under the linear cost

asumption, it is sufficient to only define the C(hi, Ij ,m) values. The cost function

is:

C(hi, Ij ,m) =

α if j ∈ {1, . . . , n} and vi = vj1 or vi = vj2

Z if j ∈ {n + 1, . . . , n + k} and n + i = j

β otherwise

The constant α > 0 is chosen arbitrarily, and β = mT + 1 so that if a heuristic

computes an instance with this cost (even with all the resources), the correspond

solution cannot be under the threshold value T . We will fix the values of T and Z

later. The basic idea of this reduction is the same as for the d − RSSP problem:

if there is a vertex cover of size x, then there is a good naive solution S1 which

gives one “extra” resource to each of the x corresponding heuristics. Otherwise, we

know that any potentially good solution S must equilibrate the x extra resources

(I ′′ forces any solution to equilibrate the x), and then it is easy to see that S1 is

better than S on I ′.

More precisely, if there is a vertex cover V c = {vi1 , . . . , vix} of size x, we define

S1i = 2 if vi ∈ V c, and 1 otherwise. We have

∑ki=1 S1

i = k + x, and Opt ≤ f(S1) =

f(S1)|I′ + f(S1)|I′′ = nmα2 + Zm(k − x + x

2 ). Thus, we define the threshold value

T = nmα2 + Zm(k − x + x

2 ). This value still depends on Z, which will be defined

after.

Otherwise, let’s consider a solution S, and let a = card{Si = 1} = k−x+ j, j ∈

{0, . . . , x − 1}. Because of I ′′, a should not be too large. We proceed by cases

according to the value of j.

If j > 0, f(S) ≥ f(S)|I′′ = mZ(a + ΣSi 6=11Si

). Given that the function t(x) = 1x

is convex, we know that ΣSi 6=1t(Si) ≥ (x − j)t(ΣSi 6=1Si

x−j ) = (x − j)t( 2x−jx−j ), which

implies f(S) ≥ mZ(k − x + j + (x−j)2

2x−j ). Hence,

f(S) − T ≥ m(Z(j +(x − j)2

2x − j−

x

2) −

nα

2)



f(S) − T ≥ m(Z(xj

2(2x − j)) −

nα

2)

≥ m(Z

4−

nα

2) because (j ≥ 1)

Thus we define Z = 2nα + 1, and we get f(S) − T > 0. So in this first case, the

considered solution S is strictly over the threshold value T . In the other case (j = 0),

f(S) = f(S)|I′ +f(S)|I′′ ≥ (n−1)mα2 +mα+f(S1)|I′′ . Then, f(S)−T ≥ α

2 > 0. In

both cases, if there is no vertex cover of size x, the cost of any solution S is strictly

greater than T which implies Opt > T .

Notice that in Theorem 1 we proved the NP hardness using a linear cost func-

tion, which means that for all i, j and for every number of allocated resources

s ∈ {1, . . . ,m}, C(hi, Ij , s) = C(hi, Ij ,m)ms . This theorem implies of course that

the general r-dRSSP is also NP hard, through the “natural” reduction which

consists in writing explicitly the m values for each heuristic and each instance.

However, one could argue that it is sufficient in the linear case to only give

the C(hi, Ij ,m) values, implying that the input could be described using only

O(nklog(Max(y1,y2)(C(y1, y2,m))) + log(m)) bits. Then, the previous reduction

from the linear to the general version the r-dRSSP would not be polynomial in

log(m), but only in m. However, this O(m) dependencies is not important because

the theorem 1 even prove that the linear r-dRSSP is unary NP hard.

2.3. A first greedy algorithm: mean-allocation (MA)

To solve r-dRSSP, let us now analyze a greedy algorithm which will serve as a basis

for more sophisticated approximations presented in the next section. We consider

the algorithm mean-allocation (MA), which consists in allocating ⌊mk ⌋ processors

to each heuristic.

Let us now define some new notations, given a fixed valid solution S (not nec-

essarily produced by MA), and a fixed optimal solution S∗.

Definition 2. Let σ(j) = argmin1≤i≤kC(hi, Ij , Si) be the index of the heuristic

which finds the solution first for the instance j in S (ties are broken arbitrarily).

Let define in the same way σ∗(j) as the index of the used heuristic for the instance

j in S∗.

Definition 3. Let T (Ij) = C(hσ(j), Ij , Sσ(j)) be the processing time of instance j

in S. Let define in the same way T ∗(Ij) as the processing time of instance j in S∗.

Proposition 4. MA is a k-approximation for r-dRSSP.

Proof. Let a and b in N such that m = ak + b, b < k. Notice that m ≥ k, otherwise

there are no feasible solutions where each heuristic has at least one processor. Hence,

a is greater or equal to 1.



For any instance j ∈ {1, .., n}, we have T (Ij) = C(hσ(j), Ij , Sσ(j)) ≤

C(hσ∗(j), Ij , Sσ∗(j)) by definition of T (Ij). In the worst case, Sσ∗(j) ≤ S∗σ∗(j), im-

plying C(hσ∗(j), Ij , Sσ∗(j)) ≤S∗

σ∗(j)

Sσ∗(j)C(hσ∗(j), Ij , S

∗σ∗(j)) ≤ m−(k−1)

Sσ∗(j)T ∗(Ij) because

in the worst case the considered optimal solution allocates the maximum possible

number of resources to heuristic σ∗(j). Finally,

m − (k − 1)

Sσ∗(j)T ∗(Ij) =

ak + b − (k − 1)

aT ∗(Ij) ≤ kT ∗(Ij).

We will now study how this algorithm can be improved thanks to the use of an

oracle.

3. Approximation schemes based on oracle

3.1. Introduction

In this section, we provide approximation schemes for r-dRSSP using the oracle

formalism: we first assume the existence of a reliable oracle that can provide some

extra information for each instance, which allows to derive good approximation

ratios, and finally we will enumerate the set of the possible oracle answers to get

a “classical” (without oracle) algorithm. The concept of adding some quantifiable

information to study what improvements can be derived exists in other fields than

optimization. Let us briefly review these oracle techniques.

In the distributed context [8], a problem is called information sensitive if a few

bits of information enable to decrease drastically the execution time. The informa-

tion sensitiveness is used to classify problems by focusing on lower bounds on the

size of advice necessary to reach a fixed performance, or giving explicitly oracle

information and studying the improvement (like in [8] and [9]).

In the on-line context, this quantifiable oracle information could be recognized

in the notion of “look-ahead”. The look-ahead could be defined as a slice of the

future which is revealed to the on-line algorithm. Thus, it is possible to prove lower

and upper bounds depending on the size of this slice [1, 22].

In the context of optimization, some polynomial time approximation schemes

have been designed thanks to the guessing technique [16, 15]. This technique can

be decomposed in two steps: proving an approximation ratio while assuming that

a little part of the optimal solution is known, and finally all enumerating the pos-

sibilities for this part of the optimal solution.

In this section, we show that by choosing “correctly” the asked information, it is pos-

sible to derive very good approximation ratio, even with MA as a basis. Moreover,

we will not only apply the guessing technique, but have a methodological approach

by proving that the question asked to the oracle is somehow “the best” possible. At

last, we improve the obtained approximation scheme by using the guess approxima-

tion technique [5]. More precisely, we provide (for any g ∈ {1, . . . , k−1} and an exe-



cution time in O(kn)) a (k−g)-approximation with an information of sizea glog(m),

and a kg+1 -approximation with an information of size g(log(k) + log(m)). Then, we

prove that no information of “the same type” (coupled with MA) could lead to a

better ratio than k−gg+1 . Finally, aiming at reducing the size of the oracle answer, we

provide a ρ-approximation with an information of size g(log(k)+ j1 + log(log(m))),

where ρ is defined as:

ρ =k + g

2j1−1

g + 1.

3.2. Choosing an arbitrary subset of heuristics

As a first step, we choose arbitrarily g heuristics (denoted by {hi1 , . . . , hig} and

called “the guessed heuristics”) among the k available heuristics. In the first guess

G1, the oracle provides a part of an optimal solution: the oracle gives the number

of processors allocated to these g heuristics in an optimal solution of the restricted

dRSSP .

Definition 5 (Guess 1) Let G1 = (S∗i1

, . . . , S∗ig

), for a fixed subset (i1, . . . , ig) of

g heuristics and a fixed optimal solution S∗.

Notice that this guess can be encoded using |G1| = glog(m) bits. We first in-

troduce some notations: let k′ = k − g be the number of remaining heuristics,

s = Σgl=1S

∗il

the number of processors used in the guess, and m′ = m−s the number

of remaining processors. We also define (a′, b′) ∈ N2 such that m′ = a′k′+b′, b′ < k′.

Let us consider a first algorithm MAG which, given any guess G =

[(i1, . . . , ig)(X1, . . . ,Xg)],Xi ≥ 1, allocates Xl processors to heuristic hil, l ∈

{1, . . . , g}, and applies MA on the k′ others heuristics with the m′ remaining pro-

cessors. This algorithm used with G1 = [(i1, . . . , ig)(G1)] leads to the following

ratio.

Proposition 6. MAG1 is a (k − g)-approximation for the restricted dRSSP, for

any g ∈ {0 . . . k − 1}.

Proof. First, remark that MAG1 produces a valid solution because we know that

a′ ≥ 1 (there is at least one processor per heuristic in the optimal solution consid-

ered). Then, for any instance j treated by a guessed heuristic in the optimal solution

considered (σ∗(j) ∈ {1, . . . , g}), MAG1 is at least as good as the optimal. For the

other instances, the analysis is the same as for the algorithm MA, and leads to the

desired ratio.

In the following, instead of choosing an arbitrary subset of g heuristics, we will

look for what could be the “best” properties to ask for.

aAs the encoding of the instance is fixed, all the information sizes are given exactly, without usingthe O notation.



3.3. Choosing a convenient subset of heuristics

In this section we define a new guess, which is larger than G1, but leads to a better

approximation ratio. As shown in [4], the “difficult” instances seem to be the ones

where the optimal solution only uses a few heuristics (meaning that the major part

of the computation time is only due to these few heuristics). For example, the worst

cases of MA and MAG1 occur when the optimal uses only one heuristic and allocates

almost all the resources to it. Hence, we are interested in the most useful heuristics

and we introduce the following definition. For any heuristic hi, i ∈ {1, .., k}, let

T ∗(hi) = Σj/σ∗(j)=iT∗(Ij) be the “useful” computation time of heuristic i in the

solution S∗. We define the second guess as follows.

Definition 7 (Guess 2) Let G2 = [(i∗1, . . . , i∗g), (S

∗i∗1

, ..., S∗i∗g

)], be the number of

processors allocated to the g most efficient heuristics (which means T ∗(hi∗1) ≥ .. ≥

T ∗(hi∗g ) ≥ T ∗(hi),∀i /∈ {i1, .., ig}) in a fixed optimal solution S∗.

Notice that this guess can be encoded using |G2| = g(log(k) + log(m)) bits

to indicate which subset of g heuristics must be chosen, and the allocation of the

heuristics.Thanks to this larger guess, we derive the following better ratio.

Proposition 8. MAG2 is a kg+1 -approximation for the r-dRSSP.

Proof. For the sake of clarity, we can assume without loss of generality that the

heuristics indicated by the oracle are the g first one, meaning that (i∗1, . . . , i∗g) =

(1, . . . , g). The proof with an arbitrary cost function is structured as the one in [4]

with linear cost assumption. Let X+ = {i ∈ {g + 1, . . . , k}|Si > S∗i } be the set of

“non-guessed” heuristics for which MAG2 allocated more than the optimal number

of resources. We define in the same way X− = {i ∈ {g + 1, . . . , k}|Si ≤ S∗i }.

TMAG2 =

g∑

i=1

∑

j/σ∗(j)=i

T (Ij) +∑

i∈X+

∑

j/σ∗(j)=i

T (Ij) +∑

i∈X−

∑

j/σ∗(j)=i

T (Ij)

≤

g∑

i=1

∑

j/σ∗(j)=i

T ∗(Ij) +∑

i∈X+

∑

j/σ∗(j)=i

T ∗(Ij) +∑

i∈X−

∑

j/σ∗(j)=i

S∗i

SiT ∗(Ij)

=

g∑

i=1

T ∗(hi) +∑

i∈X+

T ∗(hi) +∑

i∈X−

S∗i

SiT ∗(hi)

=

k∑

i=1

T ∗(hi) +∑

i∈X−

(S∗

i

Si− 1)T ∗(hi)

TMAG2 ≤ Opt + M (

∑

i∈X− S∗i

a′− card(X−))

︸︷︷︸

λ

, with M = maxi∈{g+1,...,k}(T∗(hi))



Then, we claim that λ ≤ k′ − 1. Let j = card{X−}. We can assume j ≥ 1,

otherwise MAG2 is optimal. Using the same notations (m′ = a′k′ + b′, a′ ≥ 1, b′ <

k′), we have∑

i∈X− S∗i = m′−

∑

i∈X+ S∗i ≤ m′−(k′−j). Thus, λ ≤ m′−k′+j(1−a′)

a′ ≤a′k′+b′−(k′−1)−a′

a′ ≤ k′ − 1.

Moreover, Opt = Σgi=1T

∗(hi) + Σki=g+1T

∗(hi) ≥ gT ∗(hg) + M ≥ (g + 1)M .

Finally, the ratio for MAG2 is r ≤ 1 + k′−1g+1 = k

g+1 .

3.4. Tightness: comparison with the best subset of heuristic

In the previous subsection, we investigated a “convenient” property to decide which

subset of heuristics should be asked to the oracle. By asking the allocation of a subset

of g heuristics satisfying Property 7 (rather than an arbitrary subset of size g), we

improved the (k− g)-approximation ratio to a kg+1 ratio. This drastic improvement

leads to a natural question: is there another property that would lead to really better

approximation ratio than kg+1? As we will see in Proposition 9, we investigated this

question and found that no property leads to a better ratio than k−gg+1 .

Proposition 9 (Tightness) There is no selection property (i.e. a criteria to select

for which subset of g heuristics we ask the optimal allocation to the oracle) that leads

to a better ratio than k−gg+1 , even for a linear cost function.

Proof. To prove this statement, we construct an instance such that whatever

the selected subset of g heuristics (i1, . . . , ig), the corresponding guess G =

[(i1, . . . , ig)(S∗i1

, . . . , S∗ig

)] is such that MAG ≥ k−gg+1Opt.

Let us define now this particular instance X, for fixed size of guess g (we use the

same notation k′ = k−g). We consider k heuristics, m = (g+2)k′−1 resources, and

a set I = I ′ ∪ I ′′ of k instances, with I ′ = {I1, . . . , Ig+1} and I ′′ = {Ig+2, . . . , Ik}.

Given that we are under the linear cost assumption, it is sufficient to only define

the C(hi, Ij ,m) values. The cost function is:

C(hi, Ij ,m) =

Z if j ∈ {1, . . . , g + 1} and i = j

ǫ if j ∈ {g + 2, . . . , k} and i = j

β otherwise.

We choose β = mZ + 1 so that for any solution S the cost for solving Ij only

depends on Sj (because ∀S, σ(j) = j).

We claim that the optimal solution S∗ for Xc allocates k′ resources to heuristic

hi, i ∈ {1, . . . , g + 1}, and 1 resources to hi, i ∈ {g + 2, . . . , k}. Notice that the total

number of allocated resources is equal to m. The cost of S∗ is f(S∗) = m((g+1) Zk′ +

(k′−1)ǫ). We will now prove that this solution is optimal with a similar argument as

in the NP hardness proof: any “good” solution must allocate as many resources as

possible (ie (g+1)k′) to solve the first g+1 instances, and moreover these resources

must be equitably distributed to the first g + 1 heuristics. More precisely, consider

a solution S = {S1, . . . , Sk} such that ∃i0 ∈ {1, . . . , g + 1}/Si0 = k′ − j, j ≥ 1.

Then, f(S) ≥ f(S)|I′ = m( ZSi0

+ Σi∈{1,...,g+1},i 6=i0ZSi

). Using the same argument of



convexity, we get f(S) ≥ mZ( 1Si0

+ g ggk′+j ) Finally, f(S) − f(S∗) ≥ m(Z( 1

k′−j +

g2

gk′+j −g+1k′ )− (k′−1)ǫ) = m(Z j2(g+1)

k′(gk′+j)(k′−j) − (k′−1)ǫ) > 0 for Z arbitrary large.

Hence, S∗ is an optimal solution for X.

Let us now analyse the cost of MAG for any subset {i1, . . . , ig}. Let x =

Card({i1, . . . , ig} ∩ {g + 2, . . . , k}). Notice that 0 ≤ x ≤ min(g, k′ − 1) The total

number of resources in the guess is s = (g−x)k′+x, and m′ = (x+1)k′+k′−1−x,

implying m′ < (x + 2)k′. Then, the cost of MAG (under the linear cost as-

sumption) is TMAG ≥ m((g − x) Zk′ + (x + 1)Z

α ), with α ≤ (x + 1). Thus,

TMAG ≥ m((g − x) Zk′ + Z) ≥ mZ, and

TMAG

Opt ≥ Z(g+1)Z

k′ +(k′−1)ǫ−→

Z→∞

k′

g+1 .

Notice that the previous instance could be used to prove that the kg+1 ratio

of MAG2 is tight. Indeed, with Z large enough we will have G2 = [(1, 2, . . . , g −

1, g), (k′, . . . , k′)] andT

MAG2

Opt ≥g Z

k′ +Z

(g+1) Zk′ +(k′−1)ǫ

−→Z→∞

kg+1 .

3.5. Improvements with guess approximation

The idea of the guess approximation technique (introduced in [5]) is to find how to

“contract” the answer of the oracle, without neither loosing too much information

nor worsening the approximation ratio. We now look for what could be contracted

here. In the case of guess 2, the oracle provides two types of information: a set of

indices of heuristics (which verify a particular property) and a set of numbers of

resources. The first type of information seems to be hard to approximate. Indeed,

the information here is intrinsically binary, that is a given heuristic satisfies or

not a given property. Thus, we are more interested in approximating the second

part of the oracle information: the number of processors allocated to particular

heuristics (in an optimal solution). Using the same notation as in 7, let G2 =

[(i∗1, . . . , i∗g), (S

∗i∗1

, ..., S∗i∗g

)] be the contracted answer.

In order to define “correctly” the S∗il, let us consider the two following points.

First, notice that it could be wrong to allocate more processors than the optimal

for the guessed heuristics (i.e.∑g

l=1 S∗il

>∑g

l=1 S∗il), because there could be not

enough remaining resources to allocate to the “non guessed” heuristics, leading to

an infeasible solution. Thus, the contraction can be chosen such that∑g

l=1 S∗il

≤∑g

l=1 S∗il

(we will even choose S∗il≤ S∗

il,∀l). Secondly, using only x resources instead

of x + ǫ could be very bad if x is small.

Taking into account these two remarks, let us define the S∗il

as follows. We

consider a mantissa-exponent representation for the S∗il, with a fixed sizeb j1 ∈

{1, .., ⌈log(m)⌉} of mantissa. Thus, S∗il

= ail2eil +bil

, where ailis encoded on j1 bits,

0 ≤ eil≤ ⌈log(m)⌉−j1, and bil

≤ 2eil −1. Then, we define S∗il

= ail2eil . Notice that

the length of the approximated guess becomes |G2| = Σgl=1(log(il) + |ail

| + |eil|) ≤

bIn all the paper, log denote the log2 function



g(log(k) + j1 + log(log(m))). We now study the approximation ratio derived with

the same algorithm as previously.

Proposition 10. MAG2 is ak+ g

2j1−1

g+1 -approximation for r-dRSSP.

Proof. Again, let us assume without loss of generality that (i∗1, . . . , i∗g) = (1, . . . , g).

We first prove that ∀i ∈ {1, . . . , g}, S∗i /S∗

i ≤ β, with β = 1 + 12j1−1 . If S∗

i ≤ 2j1 − 1,

we have S∗i = S∗

i because S∗i can be written with j1 bits. Otherwise, S∗

i /S∗i =

ai2ei+bi

ai2ei≤ 1 + 1

ai≤ 1 + 1

2j1−1 = β.

Then, the proof can be directly adapted from the Proposition 8 (we use the

same notation X+ and X−):

TMAG2 ≤ β

g∑

i=1

T ∗(hi) +∑

i∈X+

T ∗(hi) +∑

i∈X−

S∗i

SiT ∗(hi)

= β

k∑

i=1

T ∗(hi) +∑

i∈X+

(1 − β)T ∗(hi) +∑

i∈X−

(S∗

i

Si− β)T ∗(hi)

≤ βOpt + M (

∑

i∈X− S∗i

a′− βcard(X−))

︸︷︷︸

λ

, with M = maxi∈{g+1,...,k}(T∗(hi))

For the same reason as in proposition 8, we have λ ≤ k′ − β. Then, the ratio of¯MAG2 is r ≤ β + k′−β

g+1 =k+ g

2j1−1

g+1 .

Notice that the MAG1 algorithm could also be improved with the guess ap-

proximation technique. We would get a β(k − g) ratio, using an information of size

j1 + log(log(m)). In our previous work, we also considered another naive algorithm

(which simply redistribute a well chosen fraction of the resource given to the guessed

heuristics to the other), however it does not bring any significant improvement over

the algorithms presented above.

4. Experiments

In our previous work [4], we already made experiments for MAG1 and MAG2 to

compare their execution times and returned values (using the linear cost assump-

tion). Thus we will focus in these experiments on two axes: studying the impact of

the guess approximation on the execution times and returned values, and investi-

gating an example of the non linear case.

4.1. Description of the protocol

4.1.1. Inputs of the r-dRSSP used for the experiments

We applied our algorithms on the satisfiability problem (SAT). The SAT problem

consists in determining whether a formula of a logical proposition given as a con-

junction of clauses is satisfied for at least one interpretation. Since this hard problem



is very well known, there exist many heuristics that have been proposed to provide

solutions for it.

Let us describe here how we constructed our inputs for the experiments. We used

a SAT database (SatExc) which gives for a set of 23 heuristics (SAT solvers) and a

benchmark of 1303 instances for SAT the CPU execution times (on a single machine)

of each heuristics on the 1303 instances of the benchmark. Thus we didn’t actually

run these heuristics, but we used these CPU times to have a realistic matrix cost.

The 1303 instances of the SatEx database are issued from many domains where

the SAT problem are encountered. Some of them are: logistic planning, formal

verification of microprocessors and scheduling. These instances are also issued from

many challenging benchmarks for SAT which are used in one of the most popular

annual SAT competition d.

The SatEx database contains 23 heuristics issued from three main SAT solvers

family [17]. These are:

• The DLL family with the heuristics: asat, csat, eqsatz, nsat, sat − grasp,

posit, relsat, sato, sato − 3.2.1, satz, satz − 213, satz − 215, zchaff ;

• The DP family with : calcres, dr, zres;

• The randomized DLL family with : ntab, ntab−back, ntab−back2, relsat−

200.

Other heuristics are heerhugo, modoc, modoc − 2.0

We define thanks to these 1303 ∗ 23 values all the C(hi, Ij ,m), for all i and j. In

the linear case, these values are sufficient to entirely define the cost matrix. For the

experiments concerning the non linear case, we have chosen a logarithmic speedup,

meaning that we defined C(hi, Ij , x) =C(hi,Ij ,1)

log(x) . All the considered inputs have

the 1303 instances. For the inputs of the r-dRSSP with k heuristics, k < 23, we

randomly chosen (using an uniform distribution) a subset of heuristics of size k.

4.1.2. Description of the measures

There are two types of results: the returned values (the computed cost for solving

the considered input) and the execution times. The only difficulty for measuring the

returned values concerns MAG1 and MAG1 . Indeed, recall that these algorithms

use an arbitrary subset of g heuristics. Thus, the returned values could depend

critically on the chosen subset. To avoid this problem we considered the mean cost

of these algorithm over 30 experiments, while choosing randomly (using an uniform

distribution) a subset of g heuristic for each experiment and keeping unchanged all

the other parameters. The figures show the standard deviations, which were small

in all the experiments.

Concerning the execution times, these experiments were done on a AMD

chttp://www.lri.fr/~simon/satex/satex.php3dhttp://www.satcompetition.org



Opteron 246 CPU with 2 cores and 2 GB of memory. For MAG1 and MAG1 ,

we considered their mean execution times over the 30 experiments (the standard

deviation was negligible).

4.2. Experiment 1

The goal of the first experience is to study the impact of the guess approximation

technique on the returned values. Thus, the comparison are made between the cost

of MAG1 , MAG2 and the one of MAG1 , MAG2 for different values of g. The input

of this experiment is constructed with the 23 heuristics, and m = 100 machines. The

j1 parameter used in the MAGi algorithm must be between 1 and 6. We decided to

only show the results for two representative values of j1, that is j1 = 1 and j1 = 4.

In this case we assumed the linear cost assumption.

0

200000

400000

600000

800000

1e+06

1 2 3Tot

alco

stfo

rso

lvin

gth

e13

03in

stan

ces

Guess number

MAMAG1

MAG1(1)MAG1(4)MAG2

MAG2(1)MAG2(4)

Fig. 1. Discrete Resource Sharing Cost with 23 heuristics and 100 resources

Figure 1 depicts the portfolio cost obtained in this experiment. MAGi(x) in this

picture corresponds to the algorithm MAGi with j1 = x. As one can observe here,

the new heuristics proposed are better than MA (which presented an absolute cost

of 4253266, or 9.50 times worse than MAG1(1)). Moreover, the guess approximation

technique (applied in section 3.5) does not degrade too much the quality of the

solutions. Indeed, the ratio between the portfolio cost computed by MAG1(1) and

MAG1 for g = 1 is equal to 1.17. For MAG2 , this ratio is equal to 1.11.



4.3. Experiment 2

In this experiment we are interested in comparisons with the optimal values and

computation time. We compare the cost (and the execution time) of MAG1 , MAG2 ,

MAG1 and MAG2 with the optimal one for different values of g. Notice that the

optimal solution is computed by simple enumeration, leading to a cost in O(mk).

Thereby, the input of this experiment is constructed with only 6 (randomly chosen)

heuristicse, and m = 50 machines. We decided to only show the results for two

representative values of j1, that is j1 = 1 and j1 = 3. In this case we also assumed

the linear cost assumption.

Figure 2 depicts the portfolio cost obtained in this experiment. One can observe

again that it is interesting to restrict the subset of allocation for MAG1 and MAG2 .

For instance, when guessing 4 heuristics, the ratio between the portfolio cost of

MAG2(1) and the optimal algorithm is equal to 1.3, which is actually lower than the

theoretical ratio equal to 6+4/25 = 1.6. Notice also that when guessing 4 heuristics

with j1 = 3, MAG2(3) finds the optimal portfolio cost. We also illustrate through

this experiment the benefit of MAGi algorithms in considering their executions

times. In Figure 4, we present the execution times of MAGi , MAGi and the optimal

algorithm. The MAGi algorithms in general provide a lower execution time than the

other ones. For example, when guessing g = 4 heuristics, MAG1(1) is 44 times faster

than MAG1(3), which is also 5.3 times faster than MAG1 . Similarly, MAG2(1) is

201 times faster than MAG2(3), which is also 1.5 times faster than MAG2 .

4.4. Experiment 3

This experiment is exactly the same as Experiment 2, except that we assume here

the logarithmic cost function.

Figure 2 depicts the portfolio cost obtained in this experiment. This Figure

shows that the relative behaviour of the different algorithms does not change from

the linear to the logarithmic case. Indeed, the MAGi algorithms compute a solution

which is slightly worse than the MAGi ones. For instance the ratio between the

portfolio cost of MAG1 and MAG1 for g = 4 and j1 = 1 is equal to 1.02. For

MAG2 , this ratio is equal to 1.03. The comparisons with the optimal solution are

also tighter: the ratio between the portfolio cost of MAG2(1) (for g = 4) and the

optimal algorithm is equal to 1.08. These ratios are lower than in the linear case.

Indeed, if the cost function is “close to” a constant one, it seems reasonable that

the gap between the solutions decreases.

5. Conclusion

In this work we extended our previous results [4] on the r-dRSSP. The main contri-

bution are the complexity proof of the r-dRSSP, the extension (and the improvement

eFor the sake of reproducibility, the chosen heuristics were: csat, ntab − back2, modoc, dr, ntab,zchaff



0

200000

400000

600000

800000

1e+06

1.2e+06

1 2 3 4Tot

alco

stfo

rso

lvin

gth

e13

03in

stan

ces

Guess number

MAMAG1

MAG1(1)MAG1(3)MAG2

MAG2(1)MAG2(3)Opt

Fig. 2. Discrete Resource Sharing Cost with 6 heuristics and 50 resources (Linear case)

0

50000

100000

150000

200000

250000

300000

350000

400000

1 2 3 4Tot

alco

stfo

rso

lvin

gth

e13

03in

stan

ces

Guess number

MAMAG1

MAG1(1)MAG1(3)MAG2

MAG2(1)MAG2(3)Opt

Fig. 3. Discrete Resource Sharing Cost with 6 heuristics and 50 resources (Non-linear case)

using the guess approximation [5]) of previous approximation schemes [4] to the non

linear case (see Table 1), the tightness result that shows that the question asked to

the oracle was well chosen, and the experiments for these new algorithms. There

are many perspectives to continue this work, namely the proposal of a model and

new heuristics for the case of heterogeneous resources; and the study of a mixed



0.1

1

10

100

1000

1 2 3 4

Exec

uti

onti

me

Guess number

MAG1

MAG1(1)MAG1(3)MAG2

MAG2(1)MAG2(3)OPT

Fig. 4. Execution time with 6 heuristics and 50 resources (Linear case)

algorithm approximation ratio complexity

MAG1 (k − g) O(mg ∗ kn)

MAG2 kg+1 O((km)g ∗ kn)

MAG1 (1 + λ)(k − g) O((2j1 log(m))g ∗ kn)

MAG2 k+gλg+1 O((k2j1 log(m))g ∗ kn)

Table 1. Complexity of the oracle based approximation schemes, with λ = 1

2j1−1

problem with both resource sharing and time switching.

References

[1] Susanne Albers. On the influence of lookahead in competitive paging algorithms.Algorithmica, 18:283–305, 1997.

[2] P. An, A. Jula, S. Rus, S. Saunders, T. Smith, G. Tanase, N. Thomas, N. Amato, andL. Rauchwerger. STAPL: An adaptive, generic parallel C++ library. Lecture notesin computer science, pages 193–208, 2003.

[3] S. Bhowmick, V.Eijkhout, Y.Freund, E. Fuentes, and D. Keyes. Application of ma-chine learning to the selection of sparse linear solvers.

[4] M. Bougeret, P.F. Dutot, A. Goldman, Y. Ngoko, and D. Trystram. Combining mul-tiple heuristics on discrete resources. In 11th Workshop on Advances in Parallel andDistributed Computational Models APDCM, (IPDPS), 2009.

[5] M. Bougeret, P.F. Dutot, and D. Trystram. The guess approximation technique andits application to the discrete resource sharing scheduling problem. In To appear inModels and Algorithms for Planning and Scheduling Problems (MAPSP), 2009.



[6] V.A. Cicirello. Boosting Stochastic Problem Solvers Through Online Self-Analysis ofPerformance. PhD thesis, Carnegie Mellon University, 2003.

[7] J. Dongarra, G. Bosilca, Z. Chen, V. Eijkhout, GE Fagg, E. Fuentes, J. Langou,P. Luszczek, J. Pjesivac-Grbovic, K. Seymour, et al. Self-adapting numerical software(SANS) effort. IBM Journal of Research and Development, 50(2-3):223–238, 2006.

[8] Pierre Fraigniaud, Cyril Gavoille, David Ilcinkas, and Andrzej Pelc. Distributed com-puting with advice: Information sensitivity of graph coloring. In International Collo-quium on Automata, Languages and Programming (ICALP), pages 231–242, 2007.

[9] Pierre Fraigniaud, David Ilcinkas, and Andrzej Pelc. Oracle size : a new measureof difficulty for communication tasks. In 25th ACM Symposium on Principles OfDistributed Computing (PODC), Denver, Colorado, USA, 2006.

[10] MR Garey, D.S. Johnson, R.C. Backhouse, G. von Bochmann, D. Harel, CJ vanRijsbergen, J.E. Hopcroft, J.D. Ullman, A.W. Marshall, I. Olkin, et al. Computersand Intractability: A Guide to the Theory of NP-Completeness. Springer.

[11] C.P. Gomes and B. Selman. Algorithm portfolios. Artificial Intelligence, 126(1):43–62,2001.

[12] B.A. Huberman, R.M. Lukose, and T. Hogg. An economics approach to hard com-putational problems. Science, 275(5296):51, 1997.

[13] H.M. Markowitz. The early history of portfolio theory: 1600-1960. Financial AnalystsJournal, pages 5–16, 1999.

[14] T. Sayag, S. Fine, and Y. Mansour. Combining multiple heuristics. In Durand andThomas, editors, STACS 2006, 23rd Annual Symposium on Theoretical Aspects ofComputer Science, Marseille, France, February 23-25, 2006, Proceedings, volume3884 of LNCS, pages 242–253. Springer, 2006.

[15] P. Schuurman and G. Woeginger. Approximation schemes - a tutorial. In Lectures onScheduling, 2000.

[16] H. Shachnai and T. Tamir. Polynomial time approximation schemes - a survey. Hand-book of Approximation Algorithms and Metaheuristics, Chapman & Hall, Boca Raton,2007.

[17] L. Simon and P. Chatalic. SATEx: a web-based framework for SAT experimentation.Electronic Notes in Discrete Mathematics, 9:129–149, 2001.

[18] M. Streeter, D. Golovin, and S.F. Smith. Combining multiple heuristics online. Inproceedings of the national conference on artificial intelligence, volume 22, page 1197.Menlo Park, CA; Cambridge, MA; London; AAAI Press; MIT Press; 1999, 2007.

[19] S. Talukdar, L. Baerentzen, A. Gove, and P. De Souza. Asynchronous teams: Coop-eration schemes for autonomous agents. Journal of Heuristics, 4(4):295–321, 1998.

[20] S. Weerawarana, E.N. Houstis, J.R. Rice, A. Joshi, and C.E. Houstis. PYTHIA: aknowledge-based system to select scientific algorithms. ACM Transactions on Math-ematical Software, 22(4):447–468, 1996.

[21] H. Yu and L. Rauchwerger. Adaptive reduction parallelization techniques. In Pro-ceedings of the 14th international conference on Supercomputing, pages 66–77. ACMNew York, NY, USA, 2000.

[22] Feifeng Zheng, Yinfeng Xu, and E. Zhang. How much can lookahead help in onlinesingle machine scheduling. Information Processing Letters, 106, 2008.

APPROXIMATING THE DISCRETE RESOURCE SHARING SCHEDULING PROBLEM

Documents

Transcript of APPROXIMATING THE DISCRETE RESOURCE SHARING SCHEDULING PROBLEM