1
Iterative Integer Programming Formulation for Robust Resource Allocation in Dynamic Real-Time Systems
Sethavidh Gertphol and Viktor K. Prasanna
University of Southern California
presented at WPDRTS
April 26, 2004
2
Outline
• Introduction• Problem statement• Mathematical model• Linearization technique• IIP formulation• Experiments and results• Concluding remarks
4
Resource allocation
• issues in resource allocation– variations of parameters during run time
– performance requirements satisfaction• end-to-end latency
• throughput
– task and machine heterogeneities
– sharing of resources among tasks
5
Initial allocation
• initial allocation– initial allocation of system resources
– utilizes “off-line” resources to determine an allocation
– can afford high time complexity
• necessity for our initial allocation technique– run-time parameter variations are taken into
account
– system is more robust with respect to varying run-time parameters
6
Goal of initial allocation
• satisfy all performance requirements
• able to absorb variations of run-time parameters for the longest amount of time
• postpone the first dynamic re-allocation at run time
7
Problem statement (1)
• system model– a set of heterogeneous machines connected by a
heterogeneous network– different machines have different compute power– different network links have different capacity
Machines
8
Problem statement (2)
• application modelsensors actuators
1
9
6
3
11
8
ASDF process network
primary edge sensor communication and actuator Control
primary route
2
45
7
10
A
B
X
Y
Z
source Node
sink Node non-primary edge
9
Problem statement (3)
• run-time parameters– load level of a task: amount of data received through the primary
edge
• run-time parameter variations– load level can vary during run time– variations affect computation and communication latency of a
task– assume linear function
between latency and
load level– consider task and
machine heterogeneitieslatency
load level
ETCF matrix
machines
tasks
10
Problem statement (4)
• performance requirements– throughput requirement– end-to-end latency requirement
• performance metric– the amount of load level variations an allocation can absorb– let control load level of all tasks
– MAIL: maximum allowable increase in load level• maximum value of under condition that there is no performance
violation• this value is called max
initii ll ×+= )α1(
11
• base latency– latency of a task when there is no resource sharing
• actual latency– latency of a task when resources are shared– assumption: resource is fairly shared among all tasks– is equal to
base latency * the number of tasks running on the same machine
Mathematical model (1)-- latency
latency
load level
base latency
current load level
an entry in ETCF matrix
12
Mathematical model (2)-- normalized slackness
• normalized slackness - the percentage of “unused” latency– equal to
• must be greater than or equal to 0 to meet performance requirements
trequiremenlatency
zlatency requirement
initial latency
0
z
actual latency
-1 0
initii ll ×+= )α1(
13
Objective
actual latency
i p0
i0 -1 0p )( max
• given an allocation– suppose p0 is a task or
route that violates its requirement first
– p0 determines max
– p0 also has the lowest normalized slackness
– the minimum normalized slackness is called cmin
• comparing different allocations– an allocation has its own
p0 and cmin
– an allocation that has higher cmin has higher max
• objective function: maximize cmin
i
i
i
i
REQ
z=
+α1
α
zi
REQi
REQp0
14
Solving the problem
resources
mathematical
formulation
IIP formulation
initial allocation
tasks requirements objective function
linearization techniques
LP solver (LINDO)
15
Linearization by substitution
• non-linear terms in the mathematical formulationbase latency * the number of tasks running on the same machine
• substitutes the product with an auxiliary variable and adding constraints
• introduces additional variables and constraints• increases complexity
cxx ji ≤ ×
cxQ ≤
0≤ - iQ xx0≤ - jQ xx
1≤ - Qji xxx +
cxQ ≤
0≤ - iQ xx0≤ - jQ xx
1≤ - Qji xxx +
cxx ji ≤ × cxx ji ≤ ×
cxQ ≤
0≤ - iQ xx0≤ - jQ xx
1≤ - Qji xxx +
cxQ ≤
0≤ - iQ xx0≤ - jQ xx
1≤ - Qji xxx +
16
Given M, A, p, ETCF, ETKF, Linit, R, LREQ, THREQ
Find X where xi,l {0,1}
To Minimize
Subject to
Iterative Integer Programming (IIP) approach
1. Set threshold = 0
2. Solve the following Integer Program
Aa
ii
i
kc
MmjiAaayxx
MmjiAaaxy
MmjiAaaxy
Aax
Rrnsr
Aansk
Aansc
ljiljiljli
ljiljlji
ljililji
iMm
li
kk
ii
ii
l
,,,,0
,,,,0
,,,,0
,1
, threshold
, threshold
, threshold
,,,,
,,,
,,,
,
17
IIP approach (2)
3. If the Integer Program is infeasible, stop and use the solution of the previous iteration as solution
4. If the Integer Program has an optimal solution, calculate cmin and save the solution
5. Set threshold = cmin + and go to step 2.
is a user-provided parameter between 0 and 1
18
IIP approach (3)
• IIP maximizes cmin by solving Integer Program iteratively
• in each iteration, threshold value is the acceptable (minimum) cmin value of that iteration– threshold value starts at 0: the IIP approach is not restricted in the
first iteration
• threshold value increases in subsequent iterations, until the IP program is infeasible
• the last feasible allocation (with highest-known cmin value) is used as the solution
• cmin of the resulting allocation is within of the optimal value
19
Experiments--problem generation
• task and machine heterogeneities– use Gamma distribution to generate ETCF and ETKF matrices– high task heterogeneity and high machine heterogeneity
environment
• initial load level– use uniform distribution from 10 to 100 to generate Linit vector
• performance requirements– use a parameter called f to adjust the tightness of requirements– higher f value means requirements are more lax
20
Experiments --other approaches for comparison
• SMIP– linearizes the formulation by substitution
– encodes cmin directly into the formulation
– formulation is a mixed integer program– formulation is solved only once– is expected to produce an optimal allocation
• MIP(CBH)– linearizes the formulation by pre-selecting the value of variables
– encodes cmin directly into the formulation
– formulation is a mixed integer program– formulation is solved only once– may not produce an optimal allocation
21
Experiment #1
• goal: evaluate the performance of IIP approach• problem sets
– 3-5 machines, 12 tasks, f = 1.5
• for each problem instance– enumerate all possible initial allocation
• for each allocation, find its max
• select the allocation with the highest max (the optimal allocation)
– formulate and solve the problem using IIP (with = 0.01), SMIP and MIP(CBH) approaches
– compare max of the allocations with the optimal solution– compare the execution time of each approach
22
Results (1)
MAIL value of each approach (average over 40 problems)
0
20
40
60
80
100
120
3 4 5
number of machines
% o
f o
pti
ma
l v
alu
e
IIP
MIP(CBH)
SMIP
23
Results (2)
Execution time of each approach (average over 40 problems)
0
200
400
600
800
1000
1200
1400
3 4 5number of machines
se
co
nd
s
enumerationIIPMIP(CBH)SMIP
24
Experiment #2
• goal: evaluate the effect of on the performance of the IIP approach
• problem sets– 3-5 machines, 12 tasks, f = 1.5
• for each problem instance– enumerate all possible initial allocation
• for each allocation, find its max
• select the allocation with the highest max (the optimal allocation)
– solve the problem using the IIP approach with value equal 0.01, 0.05 and 0.1
– compare max of the resulting allocations with the optimal solution
– compare the execution time
27
Concluding remarks
• IIP approach guarantees that cmin of the resulting allocation is within of the optimal value
• trade-off between the quality of results and execution time can be achieved by adjusting the value
• future work– explore alternate methods to adjust threshold value between
iterations to make IIP faster– formulate the IIP such that the resulting allocation is optimal– additional run-time parameters– different variation patterns of the run-time parameters
29
Problem statement (5)
• performance metric– the amount of load level variations an allocation can
absorb– let controls load level of all tasks
– MAIL: maximum allowable increase in load level• maximum value of under condition that there is no
performance violation
• this value is called max
initii ll ×+= )α1(
30
Linearization
• the need for linearization: multiplication of two unknown variables in the same term
• recall: actual latency of a task is
base latency * the number of tasks running on the same machine
depend on where the task is allocated
depend on where the task is allocated and on other tasks allocated to the same machine
31
Heuristic for Choosing Nl
• Capability Based Heuristic (CBH)– let slil be the aggregated slope of ETCFi,l and ETKFi,l
– define il
– let πil be the relative speed of ai on ml
– let CCl be the computation capability of ml
– Nl is calculated as
∑'
'απ
lil
ilil
β=
∑πi
illCC =
∑∑'
' ii
ll
ll n
CC
CCN ×=
ilil
sl
1β =
33
Our approach--overview
• define system and application models• define run-time parameters and their variations• define a performance metric for initial allocation • define mathematical model for latency and
throughput of tasks• formulate the initial resource allocation as a mixed
integer programming (MIP) problem• utilize available MIP packages to solve this
problem
34
Assumptions
• applications are continuously running• multiple applications can share the same
machine and communication link– CPU cycles and communication link bandwidth are
fairly shared among all applications
35
Load level
• LL(ai): load level (amount of data received
through the primary edge) of task ai
– LL: a vector of load level of all tasks
– LLinit: a vector of initial load level of all tasks
• ETCF: an estimated-time-to-compute-function matrix
• ETKF: an estimated-time-to-communicate-function matrix