Documents
Resources
Learning Center
Upload
Plans & pricing Sign in
Sign Out
Your Federal Quarterly Tax Payments are due April 15th Get Help Now >>

Formal Bit With Determination for Nested Loop Programs

VIEWS: 0 PAGES: 21

									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:
   – Addition: 
   – 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