Reconfigurable CS294-6 Computing
Day 20 October 29, 1998 Specialization
Today
Specialization
Binding Time Specialization Time Models Specialization Benefits Expression
Next Time
Discovering and characterizing opportunities Formulating assessment
Idea
Minimize computation Instantaneous computing requirements less than general case Some data known or predictable
compute minimum computational residue
Dual of generalization we saw for local control
Opportunity Exists
Spatial unfolding of computation Fold (early) bound data into problem Common/exceptional cases
Opportunity
Arises for programmables
can change their instantaneous implementation dont have to cover all cases with a configuration can be heavily specialized
while still capable of solving entire problem
(all problems, all cases)
RC Opportunity
With bit level control
large space of optimization than word level
When branching costly
more important exploit restricted/simplified cases
While true for both spatial and temporal programmables
bigger effect/benefits for spatial
Old Example
Typical Optimization
Once know another piece of information about a computation
data value, parameter, usage limit
Fold into computation
producing smaller computational residue
Specialization Usage Classes
Known binding time Dynamic binding, persistent use
apparent empirical
Common case
Known Binding Time
Sum=0 For I=0N
Sum+=V[I]
Scale(max,min,V)
for I=0V.length
tmp=(V[I]-min) Vres[I]=tmp/(max-min)
For I=0N
VN[I]=V[I]/Sum
Dynamic Binding Time
cexp=0; For I=0V.length
if (V[I].exp!=cexp)
cexp=V[I].exp;
Thread 1:
a=src.read() if (a.newavg())
avg=a.avg()
Vres[I]=
V[I].mant<<cexp
Thread 2:
v=data.read() out.write(v/avg)
Empirical Binding
Have to check if value changed
Checking value O(N) area [pattern match] Interesting because computations
can be O(2N ) often greater area than pattern match
Common/Exceptional Case
For I=0N
Sum+=V[I] delta=V[I]-V[I-1] SumSq+=V[I]*V[I] . if (overflow)
.
For IB=0N/B
For II= 0B
I=II+IB Sum+=V[I] delta=V[I]-V[I-1] SumSq+=V[I]*V[I] .
if (overflow)
.
Binding Times
Pre-fabrication Application/algorithm selection Compilation Installation Program startup Instantiation (new ...) Epochs Loops Procedure
Exploitation Models
Full Specialization Worst-case pre-allocation Range specialization
data width
Template / placeholder
Benefit Examples
UART Pattern match Less than Multiply revisited
more than just constant propagation
ATR
UART
I8251 Intel (PC) standard UART Many operating modes
bits parity sync/async
Run in same mode for length of connection
UART FSMs
UART Composite
Pattern Match
Savings:
2N bit input computation N if N variable, maybe trim unneeded state elements store target control target
Pattern load Match
Less Than
Area depend on target value But all targets less than generic comparison
Multiply (revisited)
Specialization can be more than constant propagation Nave,
save product term generation complexity number of 1s in constant input
Can do better exploiting algebraic properties
Multiply
Never really need more than N/2 one bits in constant If more than N/2 ones:
invert c (2N+1-1-c) (less than N/2 ones) multiply by x (2N+1-1-c)x add x (2N+1-c)x subtract from (2N+1)x cx
Multiply
At most N/2 +2 adds for any constant Exploiting common subexpressions can do better:
e.g.
c=10101010 t1=x+x<<2 t2=t1<<5+t1<<1
Multiply
Example: ATR
Automatic Target Recognition
need to score image for a number of different patterns
different views of tanks, missles, etc.
reduce target image to a binary template with dont cares need to track many (e.g. 70-100) templates for each image region templates themselves are sparse
small fraction of care pixels
Example: ATR
16x16x2=512 flops to hold single target pattern 16x16=256 LUTs to compute match 256 score bits8b score ~ 500 adder bits in tree more for retiming ~800 LUTs here Maybe fit 1 generic template in XC4010 (400 CLBs)?
Example: UCLA ATR
UCLA
specialize to template ignore dont care pixels only build adder tree to care pixels exploit common subexpressions get 10 templates in a XC4010
Expressing
Generators Instantiation (disallow mutation once created) Special methods (only allow mutation with) Data Flow (binding time apparent) Control Flow
(explicitly separate common/uncommon case)
Empirical discovery -- next time (eylon)
Benefits
Much of the ben...