Changes between Version 8 and Version 9 of ToolsCourseTp10

Timestamp:

Jun 15, 2007, 5:25:58 PM (17 years ago)

Author:

anne

Comment:

--

ToolsCourseTp10

@@ -1 +1 @@
 {{{
 #!html
-<h1> TP11 VLSI : Analyse de timing</h1>
+<h1> TP10 VLSI : Vue physique de l'AMD2901</h1>
 }}}
 [[PageOutline]]
 == Objectifs ==
- * Utiliser les outils d'analyse statique de ''timing''.
- * Optimisation de votre circuit
+ * Utiliser les outils de placement et routage.
+ * Vérifier la validité du routage.
 == Exercice(s) ==
-=== Exercice 1-Analyse temporelle du bloc "Accu" ===
-En partant du fichier ''accu.ap '' fourni en annexe, vous allez effectuer différentes étapes pour obtenir l'analyse temporelle de ce bloc.
-
-Dans un premier temps , il est nécessaire d'avoir la 'vue logique' au niveau transistors de votre circuit. On spécifie la technologie utilisée par 
+=== Exercice 1-Placement ===
+La première étape consiste à placer les plots puis le coeur.
+==== Question 1 ====
+Exécutez le script suivant amd_chip.py en ayant pris soin de comprendre le contenu de ce fichier 
 {{{
->export RDS_TECHNO_NAME=/users/soft/techno/labo/035/extract/prol0.35.rds
+#!/usr/bin/python
+
+from stratus import *
+
+class amd_chip ( Model ) :
+
+  def Interface ( self ) :
+
+    self.cke     = CkIn       ( "cke")
+    self.cin     = SignalIn  ( "cin",   1 )
+    self.cout    = SignalOut  ( "cout",  1 )
+    self.np      = SignalOut      ( "np",    1 )
+    self.ng      = SignalOut      ( "ng",    1 )
+    self.ovr     = SignalOut      ( "ovr",   1 )
+    self.zero    = SignalOut      ( "zero",  1 )
+    self.signe   = SignalOut  ( "signe", 1 )
+    self.r0      = TriState  ( "r0",    1 )
+    self.r3      = TriState  ( "r3",    1 )
+    self.q0      = TriState  ( "q0",    1 )
+    self.q3      = TriState  ( "q3",    1 )
+    self.a       = SignalIn       ( "a",     4 )
+    self.b       = SignalIn       ( "b",     4 )
+    self.d       = SignalIn       ( "d",     4 )
+    self.i       = SignalIn       ( "i",     9 )
+    self.noe     = SignalIn       ( "noe",   1 )
+    self.y       = TriState  ( "y",     4 )
+
+    self.vdd     = VddIn ( "vdd"  )
+    self.vss     = VssIn ( "vss"  )
+    self.vdde    = VddIn ( "vdde" )
+    self.vsse    = VssIn ( "vsse" )
+
+
+  def Netlist ( self ) :
+
+    cin_from_pads    = Signal ( "cin_from_pads",    1 )
+    cout_to_pads     = Signal ( "cout_to_pads",     1 )
+    np_to_pads       = Signal ( "np_to_pads",       1 )
+    ng_to_pads       = Signal ( "ng_to_pads",       1 )
+    ovr_to_pads      = Signal ( "ovr_to_pads",      1 )
+    zero_to_pads     = Signal ( "zero_to_pads",     1 )
+    shift_r          = Signal ( "shift_r",          1 )
+    shift_l          = Signal ( "shift_l",          1 )
+    signe_to_pads    = Signal ( "signe_to_pads",    1 )
+    r0_to_pads       = Signal ( "r0_to_pads",       1 )
+    r3_to_pads       = Signal ( "r3_to_pads",       1 )
+    r0_from_pads     = Signal ( "r0_from_pads",     1 )
+    r3_from_pads     = Signal ( "r3_from_pads",     1 )
+    q0_to_pads       = Signal ( "q0_to_pads",       1 )
+    q3_to_pads       = Signal ( "q3_to_pads",       1 )
+    q0_from_pads     = Signal ( "q0_from_pads",     1 )
+    q3_from_pads     = Signal ( "q3_from_pads",     1 )
+    ck_ring          = Signal ( "ck_ring",          1 )
+    a_from_pads      = Signal ( "a_from_pads",      4 )
+    b_from_pads      = Signal ( "b_from_pads",      4 )
+    d_from_pads      = Signal ( "d_from_pads",      4 )
+    i_from_pads      = Signal ( "i_from_pads",      9 )
+    y_to_pads        = Signal ( "y_to_pads",        4 )
+    noe_from_pads    = Signal ( "noe_from_pads",    1 )
+    y_oe             = Signal ( "y_oe",             1 )
+    self.ckc         = Signal ( "ckc",              1 )
+
+
+    self.coeur = Inst ( "coeur"
+                     , "coeur"
+                     , map = { 'cin_from_pads' : cin_from_pads
+                             , 'cout_to_pads'  : cout_to_pads
+                             , 'np_to_pads'    : np_to_pads
+                             , 'ng_to_pads'    : ng_to_pads
+                             , 'ovr_to_pads'   : ovr_to_pads
+                             , 'signe_to_pads' : signe_to_pads
+                             , 'zero_to_pads'  : zero_to_pads
+                             , 'shift_r'       : shift_r
+                             , 'shift_l'       : shift_l
+                             , 'r0_to_pads'    : r0_to_pads
+                             , 'r3_to_pads'    : r3_to_pads
+                             , 'r0_from_pads'  : r0_from_pads
+                             , 'r3_from_pads'  : r3_from_pads
+                             , 'q0_to_pads'    : q0_to_pads
+                             , 'q3_to_pads'    : q3_to_pads
+                             , 'q0_from_pads'  : q0_from_pads
+                             , 'q3_from_pads'  : q3_from_pads
+                             , 'ck'            : self.ckc
+                             , 'a_from_pads'   : a_from_pads
+                             , 'b_from_pads'   : b_from_pads
+                             , 'd_from_pads'   : d_from_pads
+                             , 'i_from_pads'   : i_from_pads
+                             , 'y_to_pads'     : y_to_pads
+                             , 'noe_from_pads' : noe_from_pads
+                             , 'y_oe'          : y_oe
+                             , 'vdd'           : self.vdd
+                             , 'vss'           : self.vss
+                             }
+                     )
+
+    self.p_ck = Inst ( "pck_px", "p_ck"
+         , map = { 'pad'  : self.cke
+                 , 'ck'   : ck_ring
+                 , 'vddi' : self.vdd
+                 , 'vssi' : self.vss
+                 , 'vdde' : self.vdde
+                 , 'vsse' : self.vsse
+                 }
+         )
+
+    self.p_cin = Inst ( "pi_px", "p_cin"
+         , map = { 'pad'  : self.cin
+                 , 't'    : cin_from_pads
+                 , 'ck'   : ck_ring
+                 , 'vddi' : self.vdd
+                 , 'vssi' : self.vss
+                 , 'vdde' : self.vdde
+                 , 'vsse' : self.vsse
+                 }
+         )
+
+    self.p_noe = Inst ( "pi_px", "p_noe"
+         , map = { 'pad'  : self.noe
+                 , 't'    : noe_from_pads
+                 , 'ck'   : ck_ring
+                 , 'vddi' : self.vdd
+                 , 'vssi' : self.vss
+                 , 'vdde' : self.vdde
+                 , 'vsse' : self.vsse
+                 }
+         )
+
+    self.p_a = {}
+    self.p_b = {}
+    self.p_d = {}
+    for i in range ( 4 ) :
+      self.p_a[i] = Inst ( "pi_px", "p_a%d" % i
+           , map = { 'pad'  : self.a[i]
+                   , 't'    : a_from_pads[i]
+                   , 'ck'   : ck_ring
+                   , 'vddi' : self.vdd
+                   , 'vssi' : self.vss
+                   , 'vdde' : self.vdde
+                   , 'vsse' : self.vsse
+                   }
+           )
+
+      self.p_b[i] = Inst ( "pi_px", "p_b%d" % i
+           , map = { 'pad'  : self.b[i]
+                   , 't'    : b_from_pads[i]
+                   , 'ck'   : ck_ring
+                   , 'vddi' : self.vdd
+                   , 'vssi' : self.vss
+                   , 'vdde' : self.vdde
+                   , 'vsse' : self.vsse
+                   }
+           )
+
+      self.p_d[i] = Inst ( "pi_px", "p_d%d" % i
+           , map = { 'pad'  : self.d[i]
+                   , 't'    : d_from_pads[i]
+                   , 'ck'   : ck_ring
+                   , 'vddi' : self.vdd
+                   , 'vssi' : self.vss
+                   , 'vdde' : self.vdde
+                   , 'vsse' : self.vsse
+                   }
+           )
+
+    self.p_i = {}
+    for i in range ( 9 ) :
+      self.p_i[i] = Inst ( "pi_px", "p_i%d" % i
+           , map = { 'pad'  : self.i[i]
+                   , 't'    : i_from_pads[i]
+                   , 'ck'   : ck_ring
+                   , 'vddi' : self.vdd
+                   , 'vssi' : self.vss
+                   , 'vdde' : self.vdde
+                   , 'vsse' : self.vsse
+                   }
+           )
+
+    self.p_cout = Inst ( "po_px", "p_cout"
+         , map = { 'i'    : cout_to_pads
+                 , 'pad'  : self.cout
+                 , 'ck'   : ck_ring
+                 , 'vddi' : self.vdd
+                 , 'vssi' : self.vss
+                 , 'vdde' : self.vdde
+                 , 'vsse' : self.vsse
+                 }
+         )
+
+    self.p_np = Inst ( "po_px", "p_np"
+         , map = { 'i'    : np_to_pads
+                 , 'pad'  : self.np
+                 , 'ck'   : ck_ring
+                 , 'vddi' : self.vdd
+                 , 'vssi' : self.vss
+                 , 'vdde' : self.vdde
+                 , 'vsse' : self.vsse
+                 }
+         )
+
+    self.p_ng = Inst ( "po_px", "p_ng"
+         , map = { 'i'    : ng_to_pads
+                 , 'pad'  : self.ng
+                 , 'ck'   : ck_ring
+                 , 'vddi' : self.vdd
+                 , 'vssi' : self.vss
+                 , 'vdde' : self.vdde
+                 , 'vsse' : self.vsse
+                 }
+         )
+
+    self.p_ovr = Inst ( "po_px", "p_ovr"
+         , map = { 'i'    : ovr_to_pads
+                 , 'pad'  : self.ovr
+                 , 'ck'   : ck_ring
+                 , 'vddi' : self.vdd
+                 , 'vssi' : self.vss
+                 , 'vdde' : self.vdde
+                 , 'vsse' : self.vsse
+                 }
+         )
+
+    self.p_zero = Inst ( "po_px", "p_zero"
+         , map = { 'i'    : zero_to_pads
+                 , 'pad'  : self.zero
+                 , 'ck'   : ck_ring
+                 , 'vddi' : self.vdd
+                 , 'vssi' : self.vss
+                 , 'vdde' : self.vdde
+                 , 'vsse' : self.vsse
+                 }
+         )
+
+    self.p_signe = Inst ( "po_px", "p_signe"
+         , map = { 'i'    : signe_to_pads
+                 , 'pad'  : self.signe
+                 , 'ck'   : ck_ring
+                 , 'vddi' : self.vdd
+                 , 'vssi' : self.vss
+                  , 'vdde' : self.vdde
+                  , 'vsse' : self.vsse
+                  }
+         )
+
+    self.p_y = {}
+    for i in range ( 4 ) :
+      self.p_y[i] = Inst ( "pot_px", "p_y%d" % i
+           , map = { 'i'    : y_to_pads[i]
+                   , 'b'    : y_oe
+                   , 'pad'  : self.y[i]
+                   , 'ck'   : ck_ring
+                   , 'vddi' : self.vdd
+                   , 'vssi' : self.vss
+                   , 'vdde' : self.vdde
+                   , 'vsse' : self.vsse
+                   }
+           )
+
+    self.p_q0 = Inst ( "piot_px", "p_q0"
+         , map = { 'i'    : q0_to_pads
+                 , 'b'    : shift_r
+                 , 't'    : q0_from_pads
+                 , 'pad'  : self.q0
+                 , 'ck'   : ck_ring
+                 , 'vddi' : self.vdd
+                 , 'vssi' : self.vss
+                 , 'vdde' : self.vdde
+                 , 'vsse' : self.vsse
+                 }
+         )
+
+    self.p_q3 = Inst ( "piot_px", "p_q3"
+         , map = { 'i'    : q3_to_pads
+                 , 'b'    : shift_l
+                 , 't'    : q3_from_pads
+                 , 'pad'  : self.q3
+                 , 'ck'   : ck_ring
+                 , 'vddi' : self.vdd
+                 , 'vssi' : self.vss
+                 , 'vdde' : self.vdde
+                 , 'vsse' : self.vsse
+                 }
+         )
+
+    self.p_r0 = Inst ( "piot_px", "p_r0"
+         , map = { 'i'    : r0_to_pads
+                 , 'b'    : shift_r
+                 , 't'    : r0_from_pads
+                 , 'pad'  : self.r0
+                 , 'ck'   : ck_ring
+                 , 'vddi' : self.vdd
+                 , 'vssi' : self.vss
+                 , 'vdde' : self.vdde
+                 , 'vsse' : self.vsse
+                 }
+         )
+
+    self.p_r3 = Inst ( "piot_px", "p_r3"
+         , map = { 'i'    : r3_to_pads
+                 , 'b'    : shift_l
+                 , 't'    : r3_from_pads
+                 , 'pad'  : self.r3
+                 , 'ck'   : ck_ring
+                 , 'vddi' : self.vdd
+                 , 'vssi' : self.vss
+                 , 'vdde' : self.vdde
+                 , 'vsse' : self.vsse
+                 }
+         )
+
+    self.p_vddick0 = Inst ( "pvddick_px", "p_vddick0"
+         , map = { 'cko'  : self.ckc
+                 , 'ck'   : ck_ring
+                 , 'vddi' : self.vdd
+                 , 'vssi' : self.vss
+                  , 'vdde' : self.vdde
+                  , 'vsse' : self.vsse
+                  }
+         )
+
+    self.p_vssick0 = Inst ( "pvssick_px", "p_vssick0"
+         , map = { 'cko'  : self.ckc
+                 , 'ck'   : ck_ring
+                 , 'vddi' : self.vdd
+                 , 'vssi' : self.vss
+                 , 'vdde' : self.vdde
+                 , 'vsse' : self.vsse
+                 }
+         )
+
+    self.p_vddeck0 = Inst ( "pvddeck_px", "p_vddeck0"
+         , map = { 'cko'  : self.ckc
+                 , 'ck'   : ck_ring
+                 , 'vddi' : self.vdd
+                 , 'vssi' : self.vss
+                 , 'vdde' : self.vdde
+                 , 'vsse' : self.vsse
+                 }
+         )
+
+    self.p_vddeck1 = Inst ( "pvddeck_px", "p_vddeck1"
+         , map = { 'cko'  : self.ckc
+                 , 'ck'   : ck_ring
+                 , 'vddi' : self.vdd
+                 , 'vssi' : self.vss
+                 , 'vdde' : self.vdde
+                 , 'vsse' : self.vsse
+                 }
+         )
+
+    self.p_vsseck0 = Inst ( "pvsseck_px", "p_vsseck0"
+         , map = { 'cko'  : self.ckc
+                 , 'ck'   : ck_ring
+                 , 'vddi' : self.vdd
+                 , 'vssi' : self.vss
+                  , 'vdde' : self.vdde
+                  , 'vsse' : self.vsse
+                  }
+         )
+
+    self.p_vsseck1 = Inst ( "pvsseck_px", "p_vsseck1"
+         , map = { 'cko'  : self.ckc
+                 , 'ck'   : ck_ring
+                 , 'vddi' : self.vdd
+                 , 'vssi' : self.vss
+                 , 'vdde' : self.vdde
+                 , 'vsse' : self.vsse
+                 }
+         )
+
+
+  def Layout ( self ) :
+
+    ##### A COMLPETER #####
+    DefAb(XY(0,0),XY(3000,3000))
+
+    PlaceCentric(self.coeur)
+
+    PadNorth(self.p_i[3],self.p_i[4],self.p_i[5],self.p_b[0],self.p_b[1],self.p_b[2],self.p_b[3]
+                ,self.p_q0,self.p_q3,self.p_i[6],self.p_i[7])
+
+
+    PadWest(self.p_ck,self.p_d[0],self.p_d[1],self.p_d[2],self.p_zero,self.p_vsseck0,self.p_ovr
+                ,self.p_d[3],self.p_i[0],self.p_i[1],self.p_i[2])
+
+
+    PadSouth(self.p_cin,self.p_np,self.p_ng,self.p_vssick0,self.p_vddeck0,self.p_vsseck1,self.p_vddeck1
+                ,self.p_cout,self.p_y[0],self.p_y[1],self.p_y[2])
+
+
+    PadEast(self.p_y[3],self.p_signe,self.p_noe,self.p_a[0],self.p_a[1],self.p_vddick0
+                ,self.p_a[2],self.p_a[3],self.p_r0,self.p_r3,self.p_i[8])
+
+
+
+
+
+    PowerRing(3)
+
+    PlaceGlue(self.coeur)
+
+    FillCell(self.coeur)
+
+    RouteCk(self.ckc)
+
+
+mon_chip = amd_chip ( "amd_2901_dpt" )
+
+mon_chip.Interface ()
+mon_chip.Netlist ()
+#mon_chip.Layout ()
+mon_chip.View ()
+mon_chip.Save (LAYOUT)
 }}}
-pour l'extraction on spécifie les formats désirés par 
+Quels sont les fichiers obtenus? regardez en utilisant ''' graal''' le résultat du placement.
+==== Question 2 ====
+Faites varier la taille de la boite d'aboutement, qu'observez-vous ? Avez vous rencontré une limite ? peut-on en déduire la largeur des plots.
+=== Exercice 2-Routage ===
+Cette seconde étape consiste à relier les cellulesdu coeur entre elles. Vous allez pour cela utiliser l'outil '''nero''' . Consultez le ''' man ''' de ''' nero'''
 {{{
->export MBK_IN_PH=ap
->export MBK_OUT_LO=al
-}}}
-l'extraction de ''netlist'' est obtenue en utilisant l'outil '''cougar''', n'oubliez pas de consulter le man !
-{{{
->cougar -v -t -ar accu accu
-}}}
-Vous devez alors obtenir le fichier accu.al (au format texte, analysez ce que contient ce fichier).
- Pour réaliser l'analyse de timing nous allons utiliser les outils de la société '''Avertec'''. Pour pouvoir utiliser ces outils, vous devez exécuter le script fourni par
-{{{
->source avt_env.sh
-}}}
-Il est nécessaire de spécifier la '''technologie''' utilisée ainsi que les '''formats''' de fichiers utilisés:
-{{{
->export ELP_TECHNO_NAME=/users/soft/techno/labo/035/elp/prol035.elp
->export MBK_IN_LO=al
-}}}
-Puis lancer l'analyse de timing avec '''tas''' par
-{{{
->tas -nvx -t accu
+>nero -v -3 -p amd_chip_pl amd amd_route
 }}}
 ==== Question 1 ====
-Pourquoi est-il nécessaire de spécifier la technologie utilisée ''deux fois''?
+A quoi correspondent les options utilisées dans la commande ci-dessus? Faites varier le nombre de couches de métal utilisés pour le routage.
+=== Exercice 3-Validation du routage ===
+Cette étape consiste à vérifier que le routage a été effectué sans erreur. Il y a deux types de vérifications à réaliser 
+ * Vérifier le respect des règles de dessin
+ * Vérifier les interconnexions réalisées
+==== Question 1 ====
+Vérifiez le respect des règles de dessin en utilisant '''Druc''' . Vous aurez pris soin au préalable de vérifier que vous utilisez la technologie symbolique
 ==== Question 2 ====
-En utilisant l'outil '''xtas''', déterminez le plus long chemin entre une entrée et un registre de votre circuit.
+Utilisez l'outil '''cougar''' pour extraire la ''netlist ''de votre circuit au niveau "cellules de base ". Vous aurez au préalable pris soin de positionner la variable d'environnement '''MBK_OUT_LO''' au format '''al'''.
 ==== Question 3 ====
-En utilisant '''xtas''', déterminez le plus long chemin entre deux registres.
-==== Question 4 ====
-En utilisant '''xtas''', déterminez le plus long chemin entre un registre et une sortie.
-==== Question 5 ====
-En utilisant '''xtas''', déterminez le plus court chemin ainsi que le plus long chemin entre l'entrée de l'horloge de votre circuit et un registre.
-==== Question 6 ====
-Déduisez le temps nécessaire pendant lequel l'entrée '''alu_out''' doit être stable avant le front montant de l'horloge.
-==== Question 7 ====
-Déduisez de la réponse à laquestion 6 le temps de cycle minimal du bloc accu.
-==== Question 8 ====
-Indiquez à partir de combien de temps aprés le front montant de l'horloge, la sortie '''accu''' est stable (dans le pire cas )
-==== Question 9 ====
-Existe t il un risque de ''chaine courte ''?
-=== Exercice 2-Analyse temporelle du circuit complet ===
-==== Question 1 ====
-En suivant la démarche explicitée pour le bloc accu, réalisez l'analyse temporelle de votre circuit complet
-==== Question 2 ====
-Donner la valeur de la chaîne longue.
-==== Question 3 ====
-Par où passe cette chaîne longue ? Quelle est la fréquence maximale de l'horloge pour votre circuit ?
-==== Question 4 ====
-Est il possible d'optimiser votre circuit pour accroître votre fréquence de foctionnement ?
+Comparez la ''netlist'' extraite à celle d'origine (avnt routage) en utilisant l'outil '''lvx'''
+
+