SCHEDULING

W
Shared by:
Categories
Tags
-
Stats
views:
27
posted:
12/2/2011
language:
English
pages:
122
Document Sample

```							SCHEDULING
SOURCES-
Mark Manwaring        M. Balakrishnan
Kia Bazargan          Camposano,
Giovanni De Micheli   J. Hofstede,
Gupta                 Knapp,
Youn-Long Lin         MacMillen
Lin
Overview of Hardware Synthesis

assign operations to   assign times to
physical resources     operations under
under given            given constraints
constraints

general.
May be done with the consideration of additional constraints.
Outline of scheduling
• The scheduling problem.

1. Scheduling without constraints.

2. Scheduling under timing constraints.
• Relative scheduling.

3. Scheduling under resource constraints.
• The ILP model (Integer Linear Programming).
• Heuristic methods (graph coloring, etc).

Timing constraints versus resource constraints
What is   Scheduling
Example of scheduling:
ASAP
This is As Soon as
Possible Scheduling
(ASAP).
It can be used as a
bound in other
methods like ILP or
when latency only is
important, not area.
Example of Scheduling

1

Multiplier
number 2
3
More complex example of
Scheduling
What is necessary to solve the
scheduling problem?
• Circuit model:
• Sequencing graph.
• Cycle-time is given.
• Operation delays expressed in cycles.

• Scheduling:
• Determine the start times for the operations.
• Satisfying all the sequencing (timing and resource) constraints.
• Goal:
Do you remember what is
latency?
• Scheduling affects

• Area: maximum number of concurrent
operations of same type is a lower
bound on required hardware resources.

• Performance: concurrency of resulting
implementation.
Taxonomy of scheduling
problems to solve
1. Unconstrained scheduling.

2. Scheduling with timing constraints:
•    Latency.
•    Detailed timing constraints.

3. Scheduling with resource constraints.

•       Related problems:
•    Chaining. What is chaining?
•    Synchronization. What is synchronization?
•    Pipeline scheduling.
• Simplest scheduling model

• All operations have bounded delays.

• All delays are in cycles.

• Cycle-time is given.

• No constraints - no bounds on area.

• Goal
• Minimize latency.
What are types of Scheduling
Scheduling 2
Algorithms?
Scheduling problems are NP-hard, so all kind of heuristics are used

•   ASAP – As soon as possible
•   ALAP
•   List scheduling – Resource Constrained algorithms
•   Force directed algorithms – time constrained
•   Path based
•   Percolation algorithms
•   Simulated annealing
•   Tabu search and other heuristics
•   Simulated evolution
•   Linear Programming
•   Integer Linear Programming - time constrained
Types of Scheduling Processes

Assignment of operations to time (control steps)
within given constraints and minimizing a cost
function

• Time-constrained
• Resource-constrained

• With or without control (conditions)
• With or without iterations (infinite loops)

• Constructive
• Iterative
Classification of Scheduling
Algorithms
Scheduling
Algorithms
Simplest model of
scheduling
• All operations have bounded delays.

• All delays are expressed in numbers of cycles
of a single one-phase clock.
• Cycle-time is given.

• No constraints - no bounds on area.

• Goal:
• Minimize latency.
Minimum Latency
Unconstrained Scheduling
Minimum Latency Unconstrained
used when
• Unconstrained scheduling Problem
Scheduling
• Dedicated resources are used.

• Operations differ in type.

• Operations cost is marginal when compared to that of
steering logic, registers, wiring, and control logic.

• Binding is done before scheduling: resource conflicts
solved by serializing operations sharing same
resource.

• Deriving bounds on latency for constrained problems.
Minimum-latency
unconstrained
scheduling problem
tj
•   Given a set of operations V with set of
corresponding integer delays D and a partial order                                      ti
dj
on the operations E:
•   Find an integer labeling of the operations
 : V --> Z + , such that:                                     (v j , v i )
titj +dj                  di
•       t i =  (v i ),

•       t i  t j + d j  i, j such that (v j , v i )  E

•       and tn is minimum.                                              Input to
di must
be stable
• Operations with zero mobility:
•   {v 1, v 2, v 3, v 4, v 5 }.                Example of using
•   They are on the critical path.
•   Operations with mobility one:
mobility
•   {v 6 , v 7 }.                                        mobility two:
•   Operations with mobility two:
•   {v 8 , v 9 , v   10   ,v   11   }.

1. Start from
ALAP
2.Use mobility to
improve
Operation Scheduling Formalisation

Classes of scheduling algorithms
Time
Constrained
Scheduling
Latency Constrained
Scheduling
• ALAP solves a latency-constrained problem.

• Latency bound can be set to latency computed by ASAP
algorithm.

• Mobility
• Defined for each operation.
• Difference between ALAP and ASAP schedule.
• Zero mobility implies that an operation can be started only at one
given time step.
• Mobility greater than 0 measures span of time interval in which
an operation may start.

• Slack on the start time.
Time Constrained
Scheduling
Scheduling under Detailed
•   Motivation Timing Constraints
• Interface design.
• Control over operation start time.

• Constraints
• Upper/lower bounds on start-time difference of any operation pair.

• Minimum timing constraints between two operations
• An operation follows another by at least a number of prescribed time
steps
• lij  0 requires tj  ti + lij

• Maximum timing constraints between two operations
• An operation follows another by at most a number of prescribed time
steps
• uij  0 requires tj  ti + uij
Scheduling under Detailed
•   Example Timing Constraints
• Circuit reads data from a bus, performs computation, writes
result back on the bus.

• Bus interface constraint: data written three cycles after read.

• Minimum and maximum constraint of 3 cycles between read and
write operations.

• Example
• Two circuits required to communicate simultaneously to external
circuits.

• Cycle in which data available is irrelevant.

• Minimum and maximum timing constraint of zero cycles between
two write operations.
Mul delay = 2
Scheduling under detailed
timing constraints
• Motivation:
• Interface design.
• Control over
operation start time.

•   Constraints:
• Upper/lower bounds on start-time
difference of any operation pair.
•   Feasibility of a solution.
Constraint graph model
•   Start from a sequencing graph.

•   Model delays as weights on edges.

•   Add forward edges for minimum constraints.
•   Edge (vi , vj) with weight lij => t j  t i +lij .

•   Edge (vi , vj) with weight:                                               min constraint

•  - u ij => t j  t i + uij
•   because t j  t i + uij => t i  t j - uij

max constraint
Method for Scheduling with
Unbounded-Delay Operations
• Unbounded delays
• Synchronization.
• Unbounded-delay operations (e.g.
loops).
• Anchors.
• Unbounded-delay operations.
• Relative scheduling
• Schedule ops w.r. to the anchors.
• Combine schedules.
Method for Scheduling Under
Detailed Timing Constraints
• Presence of maximum timing constraints may
prevent existence of a consistent schedule.

• Required upper bound on time distance between
operations may be inconsistent with first
operation execution time.

• Minimum timing constraints may conflict with
maximum timing constraints.

• A criterion to determine existence of a schedule:
• For each maximum timing constraint uij
• Longest weighted path between vi and vj must
be  uij
So now we can calculate
this table from
Example of using       sequencing graph

constraint graph with
minimum and maximum
constraints

explain

Sequencing graph                     Constraint graph
Method for Scheduling Under
Detailed Timing Constraints

• Weight of longest path from source to a vertex is the
minimum start time of a vertex.

• Bellman-Ford or Lia-Wong algorithm provides the
schedule.

• A necessary condition for existence of a schedule is
constraint graph has no positive cycles.
Methods for Scheduling
Under Detailed Timing
Constraints

Shown
in last
slide

Will
follow
Methods for scheduling
under detailed timing constraints
• Start from the Sequencing Graph. Assumption:
• All delays are fixed and known.

• Set of linear inequalities.

• Longest path problem.

• Algorithms for the longest path problem were
discussed in Chapter 2 of De Micheli:
• Bellman-Ford,
• Liao-Wong.
Bellman-Ford’s
BELLMAN_FORD(G(V, E, W))
{                                                                algorithm
s 1 0 = 0;
for (i = 1 to N)
s   1
i   =w   0, i   ;
for (j =1 to N){
for (i =1 to N){
s   j+1
i   = min { s   j
i   , (s   j
k   +w   q, i   )},
}
if (s    j+1
i    == s j        i     i ) return (TRUE) ;
ki
}
return (FALSE)
}
Longest path problem
• Use shortest path algorithms:
• by reversing signs on weights.

• Modify algorithms:
• by changing min with max.

• Remarks:
• Dijkstra’s algorithm is not relevant.
• Inconsistent problem:
• Positive-weighted cycles.
Example – Bellman-Ford
Use shortest path algorithms:
by reversing signs on
weights.

source

• Iteration 1: l 0 =0, l 1 =3, l 2 = 1, l 3 =.             1+4=5
• Iteration 2: l 0 =0, l 1 =3, l 2 =2, l 3 =5.
• Iteration 3: l 0 =0, l 1 =3, l 2 =2, l 3 =6.             2+4=6

3 -1=2
LIAO WONG(G( V, E F, W))
{
for ( i = 1 to N)                                                                           Liao-Wong’s
l   1
i   = 0;
for ( j = 1 to |F|+ 1) {
foreach vertex v i
algorithm
l   j+1
i   = longest path in G( V, E,W            E   );
flag = TRUE;
foreach edge ( v p, v q) F {
if ( l        j+1
q   < l   j+ 1
p   +w   p,q   ){
flag = FALSE;
E = E  ( v 0 , v q) with weight ( l                j+ 1
p   +w   p,q)
}
if ( flag ) return (TRUE) ;
}
return (FALSE)
}
Example – Liao-Wong
Looking for longest path                                 (b) adjusted by
from node 0 to node 3                   edges from (a)   path from node
0 to node 2

• Iteration 1: l 0 = 0, l 1 = 3, l 2 = 1, l 3 = 5.
• Adjust: add edge (v 0 , v 2 ) with weight 2.
• Iteration 2: l 0 = 0, l 1 = 3, l 2 = 2, l 3 = 6.
Method for scheduling
with unbounded-delay operations
• Unbounded delays:
• Synchronization.
• Unbounded-delay operations (e.g. loops).

• Anchors.
• Unbounded-delay operations.

• Relative scheduling:
• Schedule operations with respect to the anchors.
• Combine schedules.
Relative
scheduling
method
Relative scheduling
method
• For each vertex:
• Determine relevant anchor set R(.).
• Anchors affecting start time.
• Determine time offset from anchors.

• Start-time:
• Expressed by:

• Computed only at run-time because delays of anchors are unknown.
Relative scheduling under timing
constraints
• Problem definition:
• Detailed timing constraints.
• Unbounded delay operations.

• Solution:
• May or may not exist.
• Problem may be ill-specified.
Relative scheduling under timing
constraints
• Feasible problem:
• A solution exists when unknown delays are zero.

• Well-posed problem:
• A solution exists for any value of the unknown delays.

• Theorem:
• A constraint graph can be made well-posed iff there
are no cycles with unbounded weights.
Example of Relative scheduling under timing constraints

(a) & (b) Ill-posed constraint (c) well-posed constraint
Relative scheduling approach
1. Analyze graph:
1. Detect anchors.
2. Well-posedness test.
3. Determine dependencies from anchors.

2. Schedule operations with respect to relevant anchors:
•   Bellman-Ford, Liao-Wong, Ku algorithms.

3. Combine schedules to determine start times:
Example of Relative
scheduling
Example of control-unit synthesized for
Relative scheduling
Operations must be serialized
Scheduling and Binding
schedule   binding
Scheduling
Scheduling Problem
Problem
formalization
Various Operator
types in Scheduling
ASAP
Scheduling
ASAP Scheduling
ASAP scheduling algorithm
ASAP ( Gs(V, E)){
Schedule v0 by setting t S 0 = 1;
repeat {
Select a vertex vi whose predecessors are all scheduled;
Schedule vi by setting t   S
i   = max t   S
j   + dj ;
}
until (vn is scheduled) ;
return (t S );
}                                            j:(vj,vi)E

Example - ASAP
• Solution
• Multipliers = 4
• ALUs = 2

Latency Time=4
ALAP
Scheduling
ALAP Scheduling

successor
ALAP scheduling algorithm

• As Late as Possible - ALAP
• Similar to depth-first search
Example ALAP
• Solution
• multipliers =
2
• ALUs = 3

Latency Time=4
Remarks on ALAP and mobility
• ALAP solves a latency-constrained problem.

• Latency bound can be set to latency computed by
ASAP algorithm. <-- using bounds, also in other approaches

• Mobility:
• Mobility is defined for each operation.
• Difference between ALAP and ASAP schedule.

• What is mobility?number of cycles that I can move
upwards or downwards the operation

• Slack on the start time.
Resource
Constrained
Scheduling under
resource constraints
• Classical scheduling problem.
• Fix area bound - minimize latency.

• The amount of available resources affects the
achievable latency.

• Dual problem:
• Fix latency bound - minimize resources.

• Assumption:
• All delays bounded and known.
Minimum latency resource-constrained
scheduling problem
• Given a set of operations V with integer delays D a partial
order on the operations E, and upper bounds {ak ; k = 1,
2,…,nres}:
• Find an integer labeling of the operations  : V --> Z+ such that :
• t i = '(v i ),
• t i t j +d j 8 i; j s:t: (v j ; v i ) 2 E,
• jfv i jT (v i ) = k and t i l < t i +d i gj a k
• and tn is minimum.
• Number of operations of any given type in
any schedule step does not exceed bound.

:V {1,2, …nres}
Scheduling under resource
constraints

• Intractable problem.

• Algorithms:
• Exact:
• Integer linear program.
• Hu (restrictive assumptions).

• Approximate:
• List scheduling.
• Force-directed scheduling.
Resource Constraint Scheduling
ML-RCS:
minimize latency,
bound on resources

MR-LCS:
minimize resources,
bound on latency
Algorithm of Hu for
Resource Constraint Scheduling

ML-RCS:
minimize latency,
bound on resources
Hu's algorithm
•   Graph is a forest.

•   Algorithm:
•  Label vertices with distance
from sink.
• Greedy strategy.
• Exact solution.

Distance
from sink

• Assumptions:
• One resource type only.           Example of using
• All operations have unit delay.
Hu’s algorithm
Algorithm
Hu's schedule with a resources
• Set step, l = 1.
• Repeat until all operations are           •All
scheduled:                                operations
• Select s  a resources with:           have unit
• All predecessors scheduled.
• Maximal labels.
delay.
• Schedule the s operations at step l.
• Increment step l = l +1.               •All
operations
have the
same type.
• Minimum latency with a = 3
resources.
Algorithm
•    Step 1:                                  Hu's schedule with a resources
• Select {v 1 , v 2 , v 6 }.
•    Step 2:
• Select {v 3 , v 7 , v 8 }.
•    Step 3:
• Select {v 4 , v 9 , v       10   }.
•    Step 4:
• Select {v 5 , v   11   }.

We always select 3
resources
• Minimum latency with a = 3
resources.
Algorithm
•    Step 1:                                  Hu's schedule with a resources
• Select {v 1 , v 2 , v 6 }.
•    Step 2:
• Select {v 3 , v 7 , v 8 }.
•    Step 3:
• Select {v 4 , v 9 , v       10   }.
•    Step 4:
• Select {v 5 , v   11   }.

We always select 3
resources
Example of Hu’s Algorithm

Distance
from sink
Example
of Hu’s
Algorithm
Exactness of Hu's algorithm
• Theorem1:
• Given a DAG with operations of the same type.

• a is a lower bound on the number of resources to complete a
schedule with latency  .
•  is a positive integer.
• Theorem2:
•Hu's algorithm applied to a tree with unit-cycle resources
achieves latency  with a resources.
• Corollary:
• Since a is a lower bound on the number of resources for
achieving , then  is minimum.
LIST
scheduling
List scheduling idea
Example

DFG

List Schedule
• Assumptions
• a1 = 2 multipliers with delay 1.
• a2 = 2 ALUs with delay 1.
• First Step
• U1,1 = {v1, v2, v6, v8}
• Select {v1, v2}
• U1,2 = {v10}; selected
• Second step
• U2,1 = {v3, v6, v8}
• select {v3, v6}
• U2,2 = {v11}; selected
• Third step
• U3,1 = {v7, v8}
• Select {v7, v8}
• U3,2 = {v4}; selected
• Fourth step
• U4,2 = {v5, v9}; selected
List Scheduling
Algorithms
• Priority list heuristics.
• Assign a weight to each vertex indicating
its scheduling priority
•Longest path to sink.
•Longest path to timing constraint.
List scheduling
algorithms
• Heuristic method for:
• 1. Minimum latency subject to resource bound.
• 2. Minimum resource subject to latency bound.

• Greedy strategy (like Hu's).

• General graphs (unlike Hu's).
LIST scheduling
List scheduling algorithm
for minimum resource Usage
List scheduling algorithm
for minimum latency for resource bound

• Candidate Operations Ul,k
• Operations of type k whose predecessors are scheduled and completed at
time step before l
U l ,k  {vi  V : Τype (vi )  k and t j  d j  l j : (v j , vi )  E}
• Unfinished operations Tl,k are operations of type k that started at earlier cycles
and whose execution is not finished at time l

Tl ,k  {vi  V : Τype (vi )  k and t j  d j  l j : (v j , vi )  E}
• Note that when execution delays are 1, Tl,k is empty.
List scheduling algorithm
for minimum latency for resource bound
LIST_L ( G(V, E), a ) {
l = 1;
repeat {
for each resource type k = 1, 2,…,nres {
Determine candidate operations U       l,k   ;
Determine unfinished operations T l,k ;
Select Sk  U l,k vertices, such that |Sk| + |T l,k|  a k ;
Schedule the S k operations at step l;
}
l = l +1;
}
until (vn is scheduled) ;
return (t );
}
algorithm
1. List scheduling
List scheduling algorithm
for minimum latency
for minimum latency for resource bound
• Assumptions:
• a 1 = 3 multipliers with
delay 2.
• a 2 = 1 ALUs with delay 1.

Now we need
two time units for multiplier
Example
• Assumptions
• a1 = 3 multipliers with delay 2.
• a2 = 1 ALU with delay 1.
•   Assume =4
•   Let a = [1, 1]T
•   First Step
• U1,1 = {v1, v2, v6, v8}
• Operations with zero slack {v1, v2}
• a = [2, 1]T
• U1,2 = {v10}
•   Second step
• U2,1 = {v3, v6, v8}
• Operations with zero slack {v3, v6}
• U2,2 = {v11}
•   Third step
• U3,1 = {v7, v8}
• Operations with zero slack {v7, v8}
• U3,2 = {v4}
•   Fourth step
• U4,2 = {v5, v9}
• Both have zero slack; a = [2, 2]T
1. List scheduling algorithm
for minimum latency for resource bound

•    Assumptions:
•   a 1 = 3 multipliers with delay 2.
•   a 2 = 1 ALUs with delay 1.

•   Solution
•   3 multipliers as assumed
•   1 ALU as assumed
•   LATENCY 7
Compute the latest possible start times
tL by ALAP ( G(V,E), );

2. List scheduling algorithm
for minimum resource usage
2. Example: List scheduling algorithm for
minimum resource usage           •   Solution
•   2 multipliers
•   1 ALU
We can move
•   LATENCY 4
them

Now we assume            From ALAP
the same time of
each operation                      • overlap
Assume 3
List Scheduling Algorithm example
multipliers             Assume 1
ALU
ML-RCS

*           *         *           *        +
*               *          +         <
-                   Other way of explanation
of the same as in last
-                 slide

t=0mul 3m 1 ALU

t=1   1 ALU

t=2 3mul
t=3 1 ALU

t=4 1 ALU

t=5 1 ALU
Now we assume the same time of
each operation
List
Scheduling
Algorithm
example
ML-RCS
Generic List
Scheduling
List Scheduling Example
•   DFG with mobility labeling (inside <>)     •   The scheduled DFG

Static-List Scheduling
•   DFG                              •   Priority list

•   Partial schedule of five nodes

The final
schedule
Classification of
Scheduling Approaches
Classification of
Scheduling Approaches
Classification of Scheduling
Approaches
Scheduling with chaining
•   Consider propagation delays of resources not in terms of cycles.

•   Use scheduling to chain multiple operations in the same control step.

•   Useful technique to explore effect of cycle-time on area/latency trade-off.

•   Algorithms:
• ILP,
• ALAP/ASAP,
• List scheduling.
Example of Scheduling with chaining

• Cycle-time: 60.
Summary

• Intractable problem in general:
• Heuristic algorithms.
• ILP formulation (small-case problems).
• Chaining:
• Incorporate cycle-time considerations.
Other scheduling
approaches
Three variants of
Scheduling
Finite Impulse
Response Filter
Example 1
IN[i]            D         D             D           D          D          D          D         D          D          D
IN[i-1]         IN[i-2]   IN[i-3]    IN[i-4]    IN[i-5]    IN[i-6]   IN[i-7]    IN[i-8]    IN[i-9]    IN[i-10]

c0        *   c1   *    c2
A0   *        c3   *     c4   *    B1
c5   *     c6   *    c7   *     c8   *     c9   *    c10   *
B0          B1            B2         B3         B4         B5        B6         B7         B8         B9

A0
+    A1     +      A2     +    A3    +    A4    +    A5    +    A6   +    A7    +    A8    +    A9    +     OUT

This can be directly used for synthesis with 11 multipliers, 10 adders and 10
registers. But the latency would be 1 multiplier + 10 adders
1
c0

*
A0
IN[i]

B0
c1

*
IN[i-1]

c2
IN[i-2]
2 multipliers                               FIR
2               +
A1
B1          *       c3 IN[i-3]
Scheduling
3                     +                   B2         *     c4 IN[i-4]

4
A2

+
A3
B3      *    c5 IN[i-5]

5                                    +                                                                               This is also bad
A4
B4     *        c6 IN[i-6]
as we use both
6                                           +                                                                        multipliers only
A5
B5         *     c7 IN[i-7]

7                                                    +                                                                  in stage 1
A6
B6         *    c8 IN[i-8]

8                                                           +
A7
B7     *     c9 IN[i-9]
There are many ways
9                                                                 +                                                  to solve this problem,
B8      *    c10 IN[i-10]

A8                                               transform the tree,
10                                                                           +
*               schedule, allocate,
B9
A9

11                                                                                  +                                     pipeline, retime
OU
Example 2  optimization
c2      *                     A0[i-2]
c5    *                     C0[i-2]
A4        c1   D                           C4        c4   D       c3
c0

+   A2   *            *    A1
+          +   C2   *            *    C1
+
A0[i-1]                                    C0[i-1]
A5                               A3        C5                               C3
D                                          D
IN[i]                                         B                                          OUT
+             A0[i]             +          +             C0[i]             +

This is not FIR,         Look to ci coefficients and compare with two
six coefficients
previous slides.
c2      *                     A0[i-2]
c5    *                     C0[i-2]
A4        c1   D                           C4        c4   D       c3
c0

+   A2   *            *    A1
+          +   C2   *            *    C1
+
A0[i-1]                                    C0[i-1]
A5                               A3        C5                               C3
D                                          D
IN[i]                                         B                                          OUT
+             A0[i]             +          +             C0[i]             +
c1   A0[i-1]   c2   A0[i-2]

1        *              *             c0 A0[i-2]

A2          A4
2             +             IN          *     c5 C0[i-2]c4   C0[i-1]

A5
2 mul, 2 add                               3                    +            +            * *                      c3   C0[i-1

A0[i]          A3                     C2
C4
4                           +                       +                    *
C5
C0[i-2]
*
C1

Filter                                                                                     5                                       +                           +
Scheduling,                                                                                                                               c0[i]              C3
6                                                    +
cont example
OUT
2
Example 3

Infinite Impulse
Response Filter
c3                                     c2            c7                                        c6
C0[i-2]
*              A0[i-                   *             *                                         *
2]

A2            c1   D         c0             A1        C2           c5   D            c4             C1            c9               c8

D0[i-1]
+   A6   *    A0[i-1]   *    A5
+             +   C6   *                 *    C5
+             *                *
C0[i-1]
A4
D                        A3        C4
D                           C3
D2
D
D1

IN                                                                                                                                                OUT
+                                                    +                                                   +
A0[i]                         B                           C0[i]                       D                 D0[i]
+                                                       +                              +

IIR Filter, 10 coefficients
IIR Filter Scheduling continued
c3A0[i-2]c1   A0[i-1]
IIR Filter, 10 coefficients
1      * *        A6
c2   A0[i-2] c0 A0[i-1]

A2
2          +            IN
C0[i-2]
C0[i-1]
A4                 * *
A1       A5
c7         c5
multipliers
3                 +        + * * c6                               C0[i-1]        C0[i-2]

A0[i]             A3        C2         C6
c4
4                        +   + * *
B             C4               C5             C1
5                          +       + c9                      C3
D0[i-1]

C0[i]
6                             +       * c8              D
D2
D0[i-1]

7                                 +       *                        D0[i]
D1

8                                     +
OUT
Minimize Resources Subject to
bound on Latency = MR-LCS

```
Related docs
Other docs by qqK40152
??? 1-54
Th�rapeutiques cibl�es en canc�rologie
NATOAVATU ESTATE, WAILEVU, VANUALEVU