# Formal Bit With Determination for Nested Loop Programs by yurtgc548

VIEWS: 0 PAGES: 21

• pg 1
```									Formal Bit With Determination
for Nested Loop Programs
David Cachera,
Tanguy Risset,
Djamel Zegaoui

Tanguy Risset   1
Outline
• Introduction/motivation

• Explaining the methodology

• Solving the Bit Width equation with
(max,+)

Tanguy Risset   2
Context and Motivations
• Context:
– High level synthesis (hardware compilation
from functional specification)
– How to go (safely) from algorithmic
description to finite precision implementation
• Specific motivations:
– Parameterized loop nests programs
– MMAlpha methodology

Tanguy Risset      3
Context and Motivations: MMAlpha
FPGA

Uniformization

Alpha   Scheduling/Mapping            ASIC
VHDL

RTL Derivation

• Provide a formal methodology based on the
strong semantic properties of the Alpha language
• But still ! Keep applicability for effective VHDL
generation          Tanguy Risset      4
BW determination: state of the art
• Formal methods :
– Provide abstract framework for solving the
problem (Gaut, Ptolemy, DeepC)
– Limited applicability
• Simulation based methods:
– Based on probabilistic models for input data
(Ptolemy, Imec,etc.)
– Time consuming processes
• Ideally: provide formal methods to speed up
the simulation.     Tanguy Risset  5
Our methodology
• Start from loop nest specification (in Alpha)
• Schedule and Place (SIMD-like specification)
• Bit Width determination:
– problem modeling
– BW equation generation
– BW equation solving
• Hardware generation (VHDL)

Tanguy Risset   6
Example: … the FIR !

system fir : {N,M | 3<=N<=M-1}
(x : {n | 1<=n<=M} of integer;
w : {i | 0<=i<=N-1} of integer)
returns
(res : {n | N<=n<=M} of integer);
var
Y : {n,i | N<=n<=M; -1<=i<=N-1} of integer;
let
Y[n,i] = case
{ | i=-1} : 0[];
{ | 0<=i} : Y[n,i-1] +w[i] * x[n-i];
esac;
res[n] = Y[n,N-1];
Tanguy Risset
tel;                                                     7
Problem modeling: error signal
• « Formal » signal s(n), implementation š(n)
• Noise signal: e(n)=s(n)- š(n)
• Noise Standard deviation:

• Signal to Noise ratio (SNR):
• Good bit width if Rs is greater than a given
value
Tanguy Risset     8
Operators modeling [Tou99]
• Let X be a signal encoded on m+n+1 bits
bm   ...   b0   . b-1    ...    b-n     b-n+1 ...

• Generated error:                 where q=2-n
• Error propagation:
– Multiplication:

Tanguy Risset               9
Architectural description in Alpha
W[t,p] = case
{ | t=p+1} : w[t-1];
{ | p+2<=t} : W[t-1,p];
esac;
XP[t,p] = case
{ | p=0} : x[t+N-1];
{ | 1<=p} : XP[t-2,p-1];
esac;
Y[t,p] = case
{ | p=-1} : 0[];
{ | 0<=p} : Y[t-1,p-1] +
W[t-1,p] * XP[t-1,p];
esac;

Tanguy Risset   10
Generation of BW equation
• Simple projection of Alpha equation on
space (p index)  (BWA=sA2):
W[t,p] = case                                          BWW[p] = Max(
{ | t=p+1} : w[t-1];                                                BWw[]
{ | p+2<=t} : W[t-1,p];
esac;
BWW[p])
XP[t,p] = case                                          BWXP[p] =case
{ | p=0} : x[t+N-1];                                 { | p=0} : BWx[]
{ | 1<=p} : XP[t-2,p-1];                             { | 1<=p} : BWXP[p-1]
esac;                                                  esac
Y[t,p] = case                                           BWY[p] = case
{ | p=-1} : 0[];                                       { | p=-1} : 0[];
{ | 0<=p} : Y[t-1,p-1] +                               { | 0<=p} :
W[t-1,p] * XP[t-1,p];
esac;
q2/12+max(BWY[p-1] + q2/12,
BWW*XP[p]+q2/12)
Tanguy Rissetesac;            11
Solving the BW equations (FIR)
• Here the solution can be easily provided by
a symbolic solver  (q=2-n):

Tanguy Risset   12
Solving the BW equations...
• In general, we solve successively the
strongly connected component of the
reduced dependence graph
input
input
X           W
V1              V2
Y
V3

Fir (3 SCC)              Other example: 1 SCC
Tanguy Risset            13
Solving BW Eq for 1 SCC
input

V1               V2

BWV1[p] = case
V1[t,p] = case                           V3              { | p=0} : l0
{ | p=0} : Input[]                                       { | p>=1} : max(BWV1[p-1]+ l,
{ | p>=1} : V1[t-1,p-1]-                                                    BWV3[p-1] ]+ l);
V3[t-2,p-1];                            esac;
esac;                                                BWV2[p] = case
V2[t,p] = case                                            { | p=0} : l0
{ | p=0} : Input[];                                      { | 1<=p} : max(BWV2[p-1]+ l,
{ | 1<=p} : V2[t-2,p-1]+                                                    BWV3[p-1] ]+ l);
V3[t-1,p-1];                            esac;
esac;                                                BWV3[p] = case
V3[t,p] = case                                            { | p=0} : l0
{ | p=0} : Input[];                                      { | 1<=p} : max(BWV1[p-1]+ l,
{ | 1<=p} : V1[t-1,p-1]+                                                    BWV2[p-1] ]+ l);
V2[t-3,p-1]                            esac;
Tanguy Risset               14
esac;
Solving the BW equations...
• General form (under some assumptions) of
the BW equation for one SCC with k
variables (for i=1..k):

• Example :

Tanguy Risset   15
Using (max,+) notations
• Å is the max and Ä is the addition

• Or:

Tanguy Risset     16
Perron-Frobenius for (max,+)
• Let MÎRmaxn´n be an irreducible matrix in
(max,+) with spectral ray rM and cyclicity
c(M), there exist an integer N such that :

• Here: c(M)=1, rM =l and N=1:

Tanguy Risset   17
Result
• If we respect our restrictions, we are able to
solve, in a parametric way the bit Width
equations for a loop nest program.
• This is the only method that solves this
problem in a parametric way (MIT did
something with DeepC but they do not
handle symbolic parameters)

Tanguy Risset    18
Restrictions of our methodology
• Linear array architecture
• BW equation solvable (i.e. no auto-adaptive
mechanism or complicated convergence
property)
• No multiplication in strongly connected
component of the graph:
a[0]=x
Do i=1,N
a[i]=a[i-1]*a[i-1]
Enddo
Tanguy Risset   19
Conclusion

• First method for parameterized loop nest bit
width determination
• Allow reducing the time needed for
simulation (probably not much more than
previous methods did)
• New typing mechanism introduced in
Alpha:
– Integer[S,8]          – C = Mul8x8-12(A,B)
– B = Trunc(C,11)
– Integer[S,3,6]
Tanguy Risset       20
Processor variable dependent BW

Tanguy Risset   21

```
To top