An Average-Case Analysis for Rate-Monotonic Multiprocessor - - PowerPoint PPT Presentation

An Average-Case Analysis for Rate-Monotonic Multiprocessor Real-time Scheduling

Andreas Karrenbauer & Thomas Rothvoß

Institute of Mathematics EPFL, Lausanne

ESA 2009

Real-time Scheduling

Given: synchronous tasks τ1, . . . , τn where task τi

◮ is periodic with period p(τi) ◮ has running time c(τi) ◮ has implicit deadline

W.l.o.g.: Task τi releases job of length c(τi) at 0, p(τi), 2p(τi), . . . Scheduling policy:

◮ multiprocessor ◮ fixed priority ◮ pre-emptive

Example

c(τ1) = 1 p(τ1) = 2 c(τ2) = 2 p(τ2) = 5

b b b

time 0 1 2 3 4 5 6 7 8 9 10

Example

Theorem (Liu & Layland ’73)

Optimal priorities:

1 p(τi) for τi (Rate-monotonic Schedule)

c(τ1) = 1 p(τ1) = 2 c(τ2) = 2 p(τ2) = 5

b b b

time 0 1 2 3 4 5 6 7 8 9 10

Example

Theorem (Liu & Layland ’73)

Optimal priorities:

1 p(τi) for τi (Rate-monotonic Schedule)

c(τ1) = 1 p(τ1) = 2 c(τ2) = 2 p(τ2) = 5

b b b

time 0 1 2 3 4 5 6 7 8 9 10

Example

Theorem (Liu & Layland ’73)

Optimal priorities:

1 p(τi) for τi (Rate-monotonic Schedule)

c(τ1) = 1 p(τ1) = 2 c(τ2) = 2 p(τ2) = 5

b b b

time 0 1 2 3 4 5 6 7 8 9 10

Example

Theorem (Liu & Layland ’73)

Optimal priorities:

1 p(τi) for τi (Rate-monotonic Schedule)

c(τ1) = 1 p(τ1) = 2 c(τ2) = 2 p(τ2) = 5

b b b

time 0 1 2 3 4 5 6 7 8 9 10

Definition

u(τ) = c(τ)

p(τ) = utilization of task τ

Feasibility test

Theorem (Lehoczky et al. ’89)

If p(τ1) ≤ . . . ≤ p(τn) then the response time r(τi) in a RM-schedule is the smallest value s.t. c(τi) +

• j<i

r(τi) p(τj)

• c(τj) ≤ r(τi)

1 machine suffices ⇔ ∀i : r(τi) ≤ p(τi).

Feasibility test

Theorem (Lehoczky et al. ’89)

If p(τ1) ≤ . . . ≤ p(τn) then the response time r(τi) in a RM-schedule is the smallest value s.t. c(τi) +

• j<i

r(τi) p(τj)

• c(τj) ≤ r(τi)

1 machine suffices ⇔ ∀i : r(τi) ≤ p(τi).

Theorem (Eisenbrand & R. ’08)

Computing a response time r(τi) is NP-hard.

Feasibility test

Theorem (Lehoczky et al. ’89)

If p(τ1) ≤ . . . ≤ p(τn) then the response time r(τi) in a RM-schedule is the smallest value s.t. c(τi) +

• j<i

r(τi) p(τj)

• c(τj) ≤ r(τi)

1 machine suffices ⇔ ∀i : r(τi) ≤ p(τi).

Theorem (Eisenbrand & R. ’08)

Computing a response time r(τi) is NP-hard.

Theorem (Liu & Layland ’73)

u(S) =

τ∈S u(τ) ≤ ln(2) ≈ 69% ⇒ 1 machine suffices

Feasibility test

Theorem (Lehoczky et al. ’89)

If p(τ1) ≤ . . . ≤ p(τn) then the response time r(τi) in a RM-schedule is the smallest value s.t. c(τi) +

• j<i

r(τi) p(τj)

• c(τj) ≤ r(τi)

1 machine suffices ⇔ ∀i : r(τi) ≤ p(τi).

Theorem (Eisenbrand & R. ’08)

Computing a response time r(τi) is NP-hard.

Theorem (Liu & Layland ’73)

u(S) =

τ∈S u(τ) ≤ ln(2) ≈ 69% ⇒ 1 machine suffices

Observation

If p(τ1) | p(τ2) | . . . | p(τn): 1 machine suffices ⇔ u(S) ≤ 1

Feasibility test (2)

Lemma (Burchard et al. ’95)

For tasks S = {τ1, . . . , τn} define

Feasibility test (2)

Lemma (Burchard et al. ’95)

For tasks S = {τ1, . . . , τn} define α(τi) := log2 p(τi) − ⌊log2 p(τi)⌋

Feasibility test (2)

Lemma (Burchard et al. ’95)

For tasks S = {τ1, . . . , τn} define α(τi) := log2 p(τi) − ⌊log2 p(τi)⌋ periods 1 2 4 8

Feasibility test (2)

Lemma (Burchard et al. ’95)

For tasks S = {τ1, . . . , τn} define α(τi) := log2 p(τi) − ⌊log2 p(τi)⌋ periods 1 2 4 8 p(τ1) p(τ2) p(τ3)

Feasibility test (2)

Lemma (Burchard et al. ’95)

For tasks S = {τ1, . . . , τn} define α(τi) := log2 p(τi) − ⌊log2 p(τi)⌋ periods 1 2 4 8 p(τ1) p(τ2) p(τ3) 1

Feasibility test (2)

Lemma (Burchard et al. ’95)

For tasks S = {τ1, . . . , τn} define α(τi) := log2 p(τi) − ⌊log2 p(τi)⌋ periods 1 2 4 8 p(τ1) p(τ2) p(τ3) 1 α(τ1)

Feasibility test (2)

Lemma (Burchard et al. ’95)

For tasks S = {τ1, . . . , τn} define α(τi) := log2 p(τi) − ⌊log2 p(τi)⌋ periods 1 2 4 8 p(τ1) p(τ2) p(τ3) 1 α(τ1) α(τ2)

Feasibility test (2)

Lemma (Burchard et al. ’95)

For tasks S = {τ1, . . . , τn} define α(τi) := log2 p(τi) − ⌊log2 p(τi)⌋ periods 1 2 4 8 p(τ1) p(τ2) p(τ3) 1 α(τ1) α(τ2) α(τ3)

Feasibility test (2)

Lemma (Burchard et al. ’95)

For tasks S = {τ1, . . . , τn} define α(τi) := log2 p(τi) − ⌊log2 p(τi)⌋ and β(S) := max

i,j |α(τi) − α(τj)|

periods 1 2 4 8 p(τ1) p(τ2) p(τ3) 1 α(τ1) α(τ2) α(τ3) β

Feasibility test (2)

Lemma (Burchard et al. ’95)

For tasks S = {τ1, . . . , τn} define α(τi) := log2 p(τi) − ⌊log2 p(τi)⌋ and β(S) := max

i,j |α(τi) − α(τj)|

One machine suffices if u(S) ≤ 1 − β(S). periods 1 2 4 8 p(τ1) p(τ2) p(τ3) 1 α(τ1) α(τ2) α(τ3) β

Algorithms for Multiprocessor Scheduling

Algorithms for Multiprocessor Scheduling

Known results:

◮ NP-hard (generalization of Bin Packing)

Algorithms for Multiprocessor Scheduling

Known results:

◮ NP-hard (generalization of Bin Packing) ◮ asymp. 1.75-apx [Burchard et al. ’95]

Algorithms for Multiprocessor Scheduling

Known results:

◮ NP-hard (generalization of Bin Packing) ◮ asymp. 1.75-apx [Burchard et al. ’95] ◮ asymp. (1 + ε)-apx (with resource augmentation) in

Oε(1) · n(1/ε)O(1) [Eisenbrand & R. ’08]

Algorithms for Multiprocessor Scheduling

Known results:

◮ NP-hard (generalization of Bin Packing) ◮ asymp. 1.75-apx [Burchard et al. ’95] ◮ asymp. (1 + ε)-apx (with resource augmentation) in

Oε(1) · n(1/ε)O(1) [Eisenbrand & R. ’08] Some papers:

• 1. Sort tasks w.r.t. some criteria (e.g. p(τi), u(τi), α(τi))

Algorithms for Multiprocessor Scheduling

Known results:

◮ NP-hard (generalization of Bin Packing) ◮ asymp. 1.75-apx [Burchard et al. ’95] ◮ asymp. (1 + ε)-apx (with resource augmentation) in

Oε(1) · n(1/ε)O(1) [Eisenbrand & R. ’08] Some papers:

• 1. Sort tasks w.r.t. some criteria (e.g. p(τi), u(τi), α(τi))
• 2. Distribute tasks in a First Fit/Next Fit way using a

sufficient feasibility criterion

Algorithms for Multiprocessor Scheduling

Known results:

◮ NP-hard (generalization of Bin Packing) ◮ asymp. 1.75-apx [Burchard et al. ’95] ◮ asymp. (1 + ε)-apx (with resource augmentation) in

Oε(1) · n(1/ε)O(1) [Eisenbrand & R. ’08] Some papers:

• 1. Sort tasks w.r.t. some criteria (e.g. p(τi), u(τi), α(τi))
• 2. Distribute tasks in a First Fit/Next Fit way using a

sufficient feasibility criterion

• 3. Perform experiments with randomly chosen tasks

Algorithms for Multiprocessor Scheduling

Known results:

◮ NP-hard (generalization of Bin Packing) ◮ asymp. 1.75-apx [Burchard et al. ’95] ◮ asymp. (1 + ε)-apx (with resource augmentation) in

Oε(1) · n(1/ε)O(1) [Eisenbrand & R. ’08] Some papers:

• 1. Sort tasks w.r.t. some criteria (e.g. p(τi), u(τi), α(τi))
• 2. Distribute tasks in a First Fit/Next Fit way using a

sufficient feasibility criterion

• 3. Perform experiments with randomly chosen tasks

Definition

Probability distribution:

◮ Adversary gives p(τi) ◮ u(τi) ∈ [0, 1] uniformly at random

Waste

Definition

Waste of a solution: #machines − u(S).

Waste

Definition

Waste of a solution: #machines − u(S). M1 M2 M3 1

Waste

Definition

Waste of a solution: #machines − u(S). τ M1 M2 M3 1

Waste

Definition

Waste of a solution: #machines − u(S). τ M1 M2 M3 u(τ) 1

Waste

Definition

Waste of a solution: #machines − u(S). τ M1 M2 M3 u(τ) 1 waste

Our algorithm

First Fit Matching Periods (FFMP):

• 1. Sort: 0 ≤ α(τ1) ≤ α(τ2) ≤ . . . ≤ α(τn) < 1
• 2. First Fit: FOR i = 1, . . . , n DO

◮ Assign τi to first machine P with u(P + τi) ≤ 1 − β(P + τi)

Our algorithm

First Fit Matching Periods (FFMP):

• 1. Sort: 0 ≤ α(τ1) ≤ α(τ2) ≤ . . . ≤ α(τn) < 1
• 2. First Fit: FOR i = 1, . . . , n DO

◮ Assign τi to first machine P with u(P + τi) ≤ 1 − β(P + τi)

M1 M2 M3 input u(τ) α ≈ 0 α ≈ 1

Our algorithm

First Fit Matching Periods (FFMP):

• 1. Sort: 0 ≤ α(τ1) ≤ α(τ2) ≤ . . . ≤ α(τn) < 1
• 2. First Fit: FOR i = 1, . . . , n DO

◮ Assign τi to first machine P with u(P + τi) ≤ 1 − β(P + τi)

M1 M2 M3 input u(τ)

Our algorithm

First Fit Matching Periods (FFMP):

• 1. Sort: 0 ≤ α(τ1) ≤ α(τ2) ≤ . . . ≤ α(τn) < 1
• 2. First Fit: FOR i = 1, . . . , n DO

◮ Assign τi to first machine P with u(P + τi) ≤ 1 − β(P + τi)

M1 M2 M3 input u(τ)

Our algorithm

First Fit Matching Periods (FFMP):

• 1. Sort: 0 ≤ α(τ1) ≤ α(τ2) ≤ . . . ≤ α(τn) < 1
• 2. First Fit: FOR i = 1, . . . , n DO

◮ Assign τi to first machine P with u(P + τi) ≤ 1 − β(P + τi)

M1 M2 M3 input u(τ)

Our algorithm

First Fit Matching Periods (FFMP):

• 1. Sort: 0 ≤ α(τ1) ≤ α(τ2) ≤ . . . ≤ α(τn) < 1
• 2. First Fit: FOR i = 1, . . . , n DO

◮ Assign τi to first machine P with u(P + τi) ≤ 1 − β(P + τi)

M1 M2 M3 input u(τ)

Our algorithm

First Fit Matching Periods (FFMP):

• 1. Sort: 0 ≤ α(τ1) ≤ α(τ2) ≤ . . . ≤ α(τn) < 1
• 2. First Fit: FOR i = 1, . . . , n DO

◮ Assign τi to first machine P with u(P + τi) ≤ 1 − β(P + τi)

M1 M2 M3 input u(τ)

Our algorithm

First Fit Matching Periods (FFMP):

• 1. Sort: 0 ≤ α(τ1) ≤ α(τ2) ≤ . . . ≤ α(τn) < 1
• 2. First Fit: FOR i = 1, . . . , n DO

◮ Assign τi to first machine P with u(P + τi) ≤ 1 − β(P + τi)

M1 M2 M3 input u(τ)

Our algorithm

First Fit Matching Periods (FFMP):

• 1. Sort: 0 ≤ α(τ1) ≤ α(τ2) ≤ . . . ≤ α(τn) < 1
• 2. First Fit: FOR i = 1, . . . , n DO

◮ Assign τi to first machine P with u(P + τi) ≤ 1 − β(P + τi)

M1 M2 M3 input u(τ)

Our algorithm

First Fit Matching Periods (FFMP):

• 1. Sort: 0 ≤ α(τ1) ≤ α(τ2) ≤ . . . ≤ α(τn) < 1
• 2. First Fit: FOR i = 1, . . . , n DO

◮ Assign τi to first machine P with u(P + τi) ≤ 1 − β(P + τi)

Running time: O(n log n)

Theorem

For n tasks with u(τi) ∈ [0, 1] uniformly at random E[waste of FFMP] ≤ O(n3/4(log n)3/8) (average utilization → 100%)

Bin Packing

Given: n items with sizes ai ∈ [0, 1] Find: Assignment to minimum number of bins of size ≤ 1

Bin Packing

Given: n items with sizes ai ∈ [0, 1] Find: Assignment to minimum number of bins of size ≤ 1 (Restricted) First Fit:

◮ FOR i = 1, . . . , n DO: Assign i to first bin B with

◮ B is empty or ◮ B contains exactly 1 item of size ≥ 1/2 and size(B) + ai ≤ 1

Bin Packing

Given: n items with sizes ai ∈ [0, 1] Find: Assignment to minimum number of bins of size ≤ 1 (Restricted) First Fit:

◮ FOR i = 1, . . . , n DO: Assign i to first bin B with

◮ B is empty or ◮ B contains exactly 1 item of size ≥ 1/2 and size(B) + ai ≤ 1

bin 1 bin 2 bin 3 input ai 0.5 1

Bin Packing

Given: n items with sizes ai ∈ [0, 1] Find: Assignment to minimum number of bins of size ≤ 1 (Restricted) First Fit:

◮ FOR i = 1, . . . , n DO: Assign i to first bin B with

◮ B is empty or ◮ B contains exactly 1 item of size ≥ 1/2 and size(B) + ai ≤ 1

bin 1 bin 2 bin 3 input ai 0.5 1

Bin Packing

Given: n items with sizes ai ∈ [0, 1] Find: Assignment to minimum number of bins of size ≤ 1 (Restricted) First Fit:

◮ FOR i = 1, . . . , n DO: Assign i to first bin B with

◮ B is empty or ◮ B contains exactly 1 item of size ≥ 1/2 and size(B) + ai ≤ 1

bin 1 bin 2 bin 3 input ai 0.5 1

Bin Packing

Given: n items with sizes ai ∈ [0, 1] Find: Assignment to minimum number of bins of size ≤ 1 (Restricted) First Fit:

◮ FOR i = 1, . . . , n DO: Assign i to first bin B with

◮ B is empty or ◮ B contains exactly 1 item of size ≥ 1/2 and size(B) + ai ≤ 1

bin 1 bin 2 bin 3 input ai 0.5 1

Bin Packing

Given: n items with sizes ai ∈ [0, 1] Find: Assignment to minimum number of bins of size ≤ 1 (Restricted) First Fit:

◮ FOR i = 1, . . . , n DO: Assign i to first bin B with

◮ B is empty or ◮ B contains exactly 1 item of size ≥ 1/2 and size(B) + ai ≤ 1

bin 1 bin 2 bin 3 input ai 0.5 1

Bin Packing

Given: n items with sizes ai ∈ [0, 1] Find: Assignment to minimum number of bins of size ≤ 1 (Restricted) First Fit:

◮ FOR i = 1, . . . , n DO: Assign i to first bin B with

◮ B is empty or ◮ B contains exactly 1 item of size ≥ 1/2 and size(B) + ai ≤ 1

Theorem (Shor ’84)

Given n items with ai ∈ [0, 1] uniformly at random E[waste of First Fit] ≤ O(n2/3 log n).

Bin Packing

Given: n items with sizes ai ∈ [0, 1] Find: Assignment to minimum number of bins of size ≤ 1 (Restricted) First Fit:

◮ FOR i = 1, . . . , n DO: Assign i to first bin B with

◮ B is empty or ◮ B contains exactly 1 item of size ≥ 1/2 and size(B) + ai ≤ 1

Theorem (Shor ’84)

Given n items with ai ∈ [0, 1] uniformly at random E[waste of First Fit] ≤ O(n2/3 log n).

Theorem (Shor ’84)

First Fit is monotone.

An auxiliary algorithm: FFMP*

• 1. Sort: 0 ≤ α(τ1) ≤ α(τ2) ≤ . . . ≤ α(τn) < 1
• 2. Partition: Sj = {τi | j−1

γ

≤ α(τi) < j

γ } → groups

• 3. First Fit: FOR i = 1, . . . , n DO

◮ Assign τi to first machine P that’s empty or ◮ P contains exactly one task τj and ◮ τj is from the same group & u(τj) ≥ 1 2(1 − 1 γ ) and ◮ u(P + τi) ≤ 1 − 1 γ

An auxiliary algorithm: FFMP*

• 1. Sort: 0 ≤ α(τ1) ≤ α(τ2) ≤ . . . ≤ α(τn) < 1
• 2. Partition: Sj = {τi | j−1

γ

≤ α(τi) < j

γ } → groups

• 3. First Fit: FOR i = 1, . . . , n DO

◮ Assign τi to first machine P that’s empty or ◮ P contains exactly one task τj and ◮ τj is from the same group & u(τj) ≥ 1 2(1 − 1 γ ) and ◮ u(P + τi) ≤ 1 − 1 γ

M1 M2 M3 M4 M5 input u(τ)

1 2(1 − 1 γ )

1 − 1

γ

An auxiliary algorithm: FFMP*

• 1. Sort: 0 ≤ α(τ1) ≤ α(τ2) ≤ . . . ≤ α(τn) < 1
• 2. Partition: Sj = {τi | j−1

γ

≤ α(τi) < j

γ } → groups

• 3. First Fit: FOR i = 1, . . . , n DO

◮ Assign τi to first machine P that’s empty or ◮ P contains exactly one task τj and ◮ τj is from the same group & u(τj) ≥ 1 2(1 − 1 γ ) and ◮ u(P + τi) ≤ 1 − 1 γ

M1 M2 M3 M4 M5 input u(τ)

1 2(1 − 1 γ )

1 − 1

γ

An auxiliary algorithm: FFMP*

• 1. Sort: 0 ≤ α(τ1) ≤ α(τ2) ≤ . . . ≤ α(τn) < 1
• 2. Partition: Sj = {τi | j−1

γ

≤ α(τi) < j

γ } → groups

• 3. First Fit: FOR i = 1, . . . , n DO

◮ Assign τi to first machine P that’s empty or ◮ P contains exactly one task τj and ◮ τj is from the same group & u(τj) ≥ 1 2(1 − 1 γ ) and ◮ u(P + τi) ≤ 1 − 1 γ

M1 M2 M3 M4 M5 S1 S2 input u(τ)

1 2(1 − 1 γ )

1 − 1

γ

An auxiliary algorithm: FFMP*

• 1. Sort: 0 ≤ α(τ1) ≤ α(τ2) ≤ . . . ≤ α(τn) < 1
• 2. Partition: Sj = {τi | j−1

γ

≤ α(τi) < j

γ } → groups

• 3. First Fit: FOR i = 1, . . . , n DO

◮ Assign τi to first machine P that’s empty or ◮ P contains exactly one task τj and ◮ τj is from the same group & u(τj) ≥ 1 2(1 − 1 γ ) and ◮ u(P + τi) ≤ 1 − 1 γ

M1 M2 M3 M4 M5 S1 S2 input u(τ)

1 2(1 − 1 γ )

1 − 1

γ

An auxiliary algorithm: FFMP*

• 1. Sort: 0 ≤ α(τ1) ≤ α(τ2) ≤ . . . ≤ α(τn) < 1
• 2. Partition: Sj = {τi | j−1

γ

≤ α(τi) < j

γ } → groups

• 3. First Fit: FOR i = 1, . . . , n DO

◮ Assign τi to first machine P that’s empty or ◮ P contains exactly one task τj and ◮ τj is from the same group & u(τj) ≥ 1 2(1 − 1 γ ) and ◮ u(P + τi) ≤ 1 − 1 γ

M1 M2 M3 M4 M5 S1 S2 input u(τ)

1 2(1 − 1 γ )

1 − 1

γ

An auxiliary algorithm: FFMP*

• 1. Sort: 0 ≤ α(τ1) ≤ α(τ2) ≤ . . . ≤ α(τn) < 1
• 2. Partition: Sj = {τi | j−1

γ

≤ α(τi) < j

γ } → groups

• 3. First Fit: FOR i = 1, . . . , n DO

◮ Assign τi to first machine P that’s empty or ◮ P contains exactly one task τj and ◮ τj is from the same group & u(τj) ≥ 1 2(1 − 1 γ ) and ◮ u(P + τi) ≤ 1 − 1 γ

M1 M2 M3 M4 M5 S1 S2 input u(τ)

1 2(1 − 1 γ )

1 − 1

γ

An auxiliary algorithm: FFMP*

• 1. Sort: 0 ≤ α(τ1) ≤ α(τ2) ≤ . . . ≤ α(τn) < 1
• 2. Partition: Sj = {τi | j−1

γ

≤ α(τi) < j

γ } → groups

• 3. First Fit: FOR i = 1, . . . , n DO

◮ Assign τi to first machine P that’s empty or ◮ P contains exactly one task τj and ◮ τj is from the same group & u(τj) ≥ 1 2(1 − 1 γ ) and ◮ u(P + τi) ≤ 1 − 1 γ

M1 M2 M3 M4 M5 S1 S2 input u(τ)

1 2(1 − 1 γ )

1 − 1

γ

An auxiliary algorithm: FFMP*

• 1. Sort: 0 ≤ α(τ1) ≤ α(τ2) ≤ . . . ≤ α(τn) < 1
• 2. Partition: Sj = {τi | j−1

γ

≤ α(τi) < j

γ } → groups

• 3. First Fit: FOR i = 1, . . . , n DO

◮ Assign τi to first machine P that’s empty or ◮ P contains exactly one task τj and ◮ τj is from the same group & u(τj) ≥ 1 2(1 − 1 γ ) and ◮ u(P + τi) ≤ 1 − 1 γ

M1 M2 M3 M4 M5 S1 S2 input u(τ)

1 2(1 − 1 γ )

1 − 1

γ

An auxiliary algorithm: FFMP*

• 1. Sort: 0 ≤ α(τ1) ≤ α(τ2) ≤ . . . ≤ α(τn) < 1
• 2. Partition: Sj = {τi | j−1

γ

≤ α(τi) < j

γ } → groups

• 3. First Fit: FOR i = 1, . . . , n DO

◮ Assign τi to first machine P that’s empty or ◮ P contains exactly one task τj and ◮ τj is from the same group & u(τj) ≥ 1 2(1 − 1 γ ) and ◮ u(P + τi) ≤ 1 − 1 γ

M1 M2 M3 M4 M5 S1 S2 input u(τ)

1 2(1 − 1 γ )

1 − 1

γ

FFMP* vs. First Fit

τi from the same group & u(τi) ≤ 1 − 1

γ

items ai := u(τi)/(1 − 1

γ )

M1 M2 M3

1 2(1 − 1 γ )

1 − 1

γ

bin 1 bin 2 bin 3

1 2

1

FFMP* vs. First Fit

τi from the same group & u(τi) ≤ 1 − 1

γ

items ai := u(τi)/(1 − 1

γ )

M1 M2 M3

1 2(1 − 1 γ )

1 − 1

γ

bin 1 bin 2 bin 3

1 2

1

◮ FFMP∗ = First Fit

FFMP* vs. First Fit

τi from the same group & u(τi) ≤ 1 − 1

γ

items ai := u(τi)/(1 − 1

γ )

M1 M2 M3

1 2(1 − 1 γ )

1 − 1

γ

bin 1 bin 2 bin 3

1 2

1

◮ FFMP∗ = First Fit

Corollary

FFMP∗ is monotone.

Consequences

Lemma

For any task set S : FFMP(S) ≤ FFMP∗(S)

Consequences

Lemma

For any task set S : FFMP(S) ≤ FFMP∗(S)

◮ Consider schedule of S w.r.t. FFMP.

M1 M2 M3 M4

Consequences

Lemma

For any task set S : FFMP(S) ≤ FFMP∗(S)

◮ Consider schedule of S w.r.t. FFMP. ◮ Delete tasks that FFMP∗ would have scheduled differently

M1 M2 M3 M4

1 2(1 − 1 γ )

1 − 1

γ

Consequences

Lemma

For any task set S : FFMP(S) ≤ FFMP∗(S)

◮ Consider schedule of S w.r.t. FFMP. ◮ Delete tasks that FFMP∗ would have scheduled differently

M1 M2 M3 M4

1 2(1 − 1 γ )

1 − 1

γ

Consequences

Lemma

For any task set S : FFMP(S) ≤ FFMP∗(S)

◮ Consider schedule of S w.r.t. FFMP. ◮ Delete tasks that FFMP∗ would have scheduled differently

M1 M2 M3 M4

1 2(1 − 1 γ )

1 − 1

γ

Consequences

Lemma

For any task set S : FFMP(S) ≤ FFMP∗(S)

◮ Consider schedule of S w.r.t. FFMP. ◮ Delete tasks that FFMP∗ would have scheduled differently

M1 M2 M3 M4

1 2(1 − 1 γ )

1 − 1

γ

Consequences

Lemma

For any task set S : FFMP(S) ≤ FFMP∗(S)

◮ Consider schedule of S w.r.t. FFMP. ◮ Delete tasks that FFMP∗ would have scheduled differently

→ S′ ⊆ S M1 M2 M3 M4

1 2(1 − 1 γ )

1 − 1

γ

Consequences

Lemma

For any task set S : FFMP(S) ≤ FFMP∗(S)

◮ Consider schedule of S w.r.t. FFMP. ◮ Delete tasks that FFMP∗ would have scheduled differently

→ S′ ⊆ S FFMP(S) = FFMP∗(S′) M1 M2 M3 M4

1 2(1 − 1 γ )

1 − 1

γ

Consequences

Lemma

For any task set S : FFMP(S) ≤ FFMP∗(S)

◮ Consider schedule of S w.r.t. FFMP. ◮ Delete tasks that FFMP∗ would have scheduled differently

→ S′ ⊆ S FFMP(S) = FFMP∗(S′)

monotonicity

≤ FFMP∗(S) M1 M2 M3 M4

1 2(1 − 1 γ )

1 − 1

γ

Main result

Theorem

E[waste of FFMP∗] ≤ O(n3/4(log n)3/8)

Main result

Theorem

E[waste of FFMP∗] ≤ O(n3/4(log n)3/8)

◮ f(m) := O(m2/3√log m) expected waste of First Fit

Main result

Theorem

E[waste of FFMP∗] ≤ O(n3/4(log n)3/8)

◮ f(m) := O(m2/3√log m) expected waste of First Fit ◮ S′ j := {τi ∈ Sj | u(τi) ≤ 1 − 1 γ } not too big tasks

Main result

Theorem

E[waste of FFMP∗] ≤ O(n3/4(log n)3/8)

◮ f(m) := O(m2/3√log m) expected waste of First Fit ◮ S′ j := {τi ∈ Sj | u(τi) ≤ 1 − 1 γ } not too big tasks ◮ Ij := {ai := u(τi)/(1 − 1 γ ) | τi ∈ S′ j}

Main result

Theorem

E[waste of FFMP∗] ≤ O(n3/4(log n)3/8)

◮ f(m) := O(m2/3√log m) expected waste of First Fit ◮ S′ j := {τi ∈ Sj | u(τi) ≤ 1 − 1 γ } not too big tasks ◮ Ij := {ai := u(τi)/(1 − 1 γ ) | τi ∈ S′ j} ◮ ∀τi ∈ S′ j : u(τi) ∈ [0, 1 − 1 γ ] uniform ⇒ ai ∈ [0, 1] uniform

Main result

Theorem

E[waste of FFMP∗] ≤ O(n3/4(log n)3/8)

◮ f(m) := O(m2/3√log m) expected waste of First Fit ◮ S′ j := {τi ∈ Sj | u(τi) ≤ 1 − 1 γ } not too big tasks ◮ Ij := {ai := u(τi)/(1 − 1 γ ) | τi ∈ S′ j} ◮ ∀τi ∈ S′ j : u(τi) ∈ [0, 1 − 1 γ ] uniform ⇒ ai ∈ [0, 1] uniform

E[waste of FFMP∗(Sj)]

Main result

Theorem

E[waste of FFMP∗] ≤ O(n3/4(log n)3/8)

◮ f(m) := O(m2/3√log m) expected waste of First Fit ◮ S′ j := {τi ∈ Sj | u(τi) ≤ 1 − 1 γ } not too big tasks ◮ Ij := {ai := u(τi)/(1 − 1 γ ) | τi ∈ S′ j} ◮ ∀τi ∈ S′ j : u(τi) ∈ [0, 1 − 1 γ ] uniform ⇒ ai ∈ [0, 1] uniform

E[waste of FFMP∗(Sj)] ≤ |Sj| · 1 γ + E[waste of FirstFit(Ij)]

Main result

Theorem

E[waste of FFMP∗] ≤ O(n3/4(log n)3/8)

◮ f(m) := O(m2/3√log m) expected waste of First Fit ◮ S′ j := {τi ∈ Sj | u(τi) ≤ 1 − 1 γ } not too big tasks ◮ Ij := {ai := u(τi)/(1 − 1 γ ) | τi ∈ S′ j} ◮ ∀τi ∈ S′ j : u(τi) ∈ [0, 1 − 1 γ ] uniform ⇒ ai ∈ [0, 1] uniform

E[waste of FFMP∗(Sj)] ≤ |Sj| · 1 γ + E[waste of FirstFit(Ij)] ≤ |Sj| γ + f(|Ij|)

Main result

Theorem

E[waste of FFMP∗] ≤ O(n3/4(log n)3/8)

◮ f(m) := O(m2/3√log m) expected waste of First Fit ◮ S′ j := {τi ∈ Sj | u(τi) ≤ 1 − 1 γ } not too big tasks ◮ Ij := {ai := u(τi)/(1 − 1 γ ) | τi ∈ S′ j} ◮ ∀τi ∈ S′ j : u(τi) ∈ [0, 1 − 1 γ ] uniform ⇒ ai ∈ [0, 1] uniform

E[waste of FFMP∗(Sj)] ≤ |Sj| · 1 γ + E[waste of FirstFit(Ij)] ≤ |Sj| γ + f(|Ij|) ≤ |Sj| γ + f(|Sj|)

Main result

Theorem

E[waste of FFMP∗] ≤ O(n3/4(log n)3/8)

◮ f(m) := O(m2/3√log m) expected waste of First Fit ◮ S′ j := {τi ∈ Sj | u(τi) ≤ 1 − 1 γ } not too big tasks ◮ Ij := {ai := u(τi)/(1 − 1 γ ) | τi ∈ S′ j} ◮ ∀τi ∈ S′ j : u(τi) ∈ [0, 1 − 1 γ ] uniform ⇒ ai ∈ [0, 1] uniform

E[waste of FFMP∗(Sj)] ≤ |Sj| · 1 γ + E[waste of FirstFit(Ij)] ≤ |Sj| γ + f(|Ij|) ≤ |Sj| γ + f(|Sj|) E[waste of FFMP∗(S)]

Main result

Theorem

E[waste of FFMP∗] ≤ O(n3/4(log n)3/8)

◮ f(m) := O(m2/3√log m) expected waste of First Fit ◮ S′ j := {τi ∈ Sj | u(τi) ≤ 1 − 1 γ } not too big tasks ◮ Ij := {ai := u(τi)/(1 − 1 γ ) | τi ∈ S′ j} ◮ ∀τi ∈ S′ j : u(τi) ∈ [0, 1 − 1 γ ] uniform ⇒ ai ∈ [0, 1] uniform

E[waste of FFMP∗(Sj)] ≤ |Sj| · 1 γ + E[waste of FirstFit(Ij)] ≤ |Sj| γ + f(|Ij|) ≤ |Sj| γ + f(|Sj|) E[waste of FFMP∗(S)] ≤

γ

• j=1

|Sj| γ + f(|Sj|)

Main result

Theorem

E[waste of FFMP∗] ≤ O(n3/4(log n)3/8)

◮ f(m) := O(m2/3√log m) expected waste of First Fit ◮ S′ j := {τi ∈ Sj | u(τi) ≤ 1 − 1 γ } not too big tasks ◮ Ij := {ai := u(τi)/(1 − 1 γ ) | τi ∈ S′ j} ◮ ∀τi ∈ S′ j : u(τi) ∈ [0, 1 − 1 γ ] uniform ⇒ ai ∈ [0, 1] uniform

E[waste of FFMP∗(Sj)] ≤ |Sj| · 1 γ + E[waste of FirstFit(Ij)] ≤ |Sj| γ + f(|Ij|) ≤ |Sj| γ + f(|Sj|) E[waste of FFMP∗(S)] ≤

γ

• j=1

|Sj| γ + f(|Sj|)

• Jensen

≤ n γ + γ · f(n/γ)

Main result

Theorem

E[waste of FFMP∗] ≤ O(n3/4(log n)3/8)

◮ f(m) := O(m2/3√log m) expected waste of First Fit ◮ S′ j := {τi ∈ Sj | u(τi) ≤ 1 − 1 γ } not too big tasks ◮ Ij := {ai := u(τi)/(1 − 1 γ ) | τi ∈ S′ j} ◮ ∀τi ∈ S′ j : u(τi) ∈ [0, 1 − 1 γ ] uniform ⇒ ai ∈ [0, 1] uniform

E[waste of FFMP∗(Sj)] ≤ |Sj| · 1 γ + E[waste of FirstFit(Ij)] ≤ |Sj| γ + f(|Ij|) ≤ |Sj| γ + f(|Sj|) E[waste of FFMP∗(S)] ≤

γ

• j=1

|Sj| γ + f(|Sj|)

• Jensen

≤ n γ + γ · f(n/γ)

γ:=n1/4/(log n)3/8

≤ O(n3/4(log n)3/8)

Open problems

◮ Problem: Is there an asymptotic PTAS for Multiprocessor

Real-time scheduling?

Open problems

◮ Problem: Is there an asymptotic PTAS for Multiprocessor

Real-time scheduling?

Thanks for your attention