| 7 |   | Le but des quatre prochaines séances de TP est de présenter quelques outils de la chaîne ALLIANCE dont : | 
                      
                        | 8 |   |   * Les outils de synthèse logique '''SYF''', '''BOOM''', '''BOOG''', '''LOON'''; | 
                      
                        | 9 |   |   * Le langage '''STRATUS''', utilisé pour la description des chemins de données; | 
                      
                        | 10 |   |   * L'éditeur graphique de netlist '''XSCH'''; | 
                      
                        | 11 |   |   * Le simulateur '''ASIMUT'''; | 
                      
                        | 12 |   |   Chaque outil possède ses propres options donnant des résultats plus ou moins adaptés | 
                      
                        | 13 |   |   suivant l'utilisation que l'on veut faire du circuit. | 
                      
                      
                        |   | 8 | Le but de ce TP est de présenter quelques outils de la chaîne ALLIANCE dont : | 
                      
                        |   | 9 |   * Les outils de synthèse logique '''SYF''', '''BOOM''', '''BOOG''', '''LOON''' ; | 
                      
                        |   | 10 |   * L'éditeur graphique de netlist '''XSCH''' ; | 
                      
                        |   | 11 |   * Le simulateur '''ASIMUT''' ; | 
                      
                        |   | 12 | Chaque outil possède ses propres options donnant des résultats plus ou moins adaptés suivant l'utilisation que l'on veut faire du circuit. | 
                      
            
                      
                        | 26 |   |  | 
                      
                        | 27 |   | Un circuit combinatoire pur ne dispose pas | 
                      
                        | 28 |   | de registres internes. De ce fait, ses sorties | 
                      
                        | 29 |   | ne dépendent que de ses entrées primaires. | 
                      
                        | 30 |   |  | 
                      
                        | 31 |   | A l'inverse, un circuit séquentiel synchrone | 
                      
                        | 32 |   | disposant de registres internes voit ses sorties | 
                      
                        | 33 |   | changer en fonction de ses entrées mais aussi | 
                      
                        | 34 |   | des valeurs mémorisées dans ses registres.  | 
                      
                        | 35 |   |  | 
                      
                      
                        |   | 19 |   == 1.1 Synthèse d'automates d'états finis == | 
                      
                        |   | 20 |  | 
                      
                        |   | 21 | Un circuit combinatoire pur ne dispose pas de registres internes. | 
                      
                        |   | 22 | De ce fait, ses sorties ne dépendent que de ses entrées primaires. | 
                      
                        |   | 23 |  | 
                      
                        |   | 24 | A l'inverse, un circuit séquentiel synchrone disposant de registres internes voit ses sorties changer en fonction de ses entrées mais aussi des valeurs mémorisées dans ses registres. | 
                      
            
                      
                        | 50 |   | Les entrées peuvent donc bouger entre deux fronts sans modifier les sorties. Par | 
                      
                        | 51 |   | contre dans le cas d'un automate de MEALY, la variation des entrées peut modifier à jour | 
                      
                        | 52 |   |  | 
                      
                        | 53 |   |  | 
                      
                        | 54 |   |  | 
                      
                        | 55 |   | = 2 SYF et VHDL = | 
                      
                        | 56 |   |  | 
                      
                        | 57 |   |  | 
                      
                        | 58 |   |  | 
                      
                        | 59 |   |  | 
                      
                        | 60 |   |  | 
                      
                        | 61 |   | Afin de décrire de tels automates, on utilise un style particulier de description | 
                      
                        | 62 |   | VHDL qui définit l'architecture '''"fsm"''' (finite-state machine). | 
                      
                        | 63 |   | Le fichier correspondant possède également l'extension fsm. A partir de ce fichier, | 
                      
                        | 64 |   | l'outil SYF effectue la synthèse d'automate et transforme cet automate abstrait en un | 
                      
                        | 65 |   | réseau booléen. '''SYF ''' génère donc un fichier VHDL au format vbe. Comme la plupart | 
                      
                        | 66 |   | des outils utilisés au laboratoire, il faut positionner certaines variables d'environnement | 
                      
                        | 67 |   | avant d'utiliser '''SYF'''. Pour les connaître, reportez-vous au man de syf. | 
                      
                        | 68 |   |  | 
                      
                        | 69 |   |  | 
                      
                        | 70 |   | = 3 Exemple = | 
                      
                      
                        |   | 34 | Les entrées peuvent donc bouger entre deux fronts sans modifier les sorties. | 
                      
                        |   | 35 | Par contre dans le cas d'un automate de MEALY, la variation des entrées peut modifier à jour | 
                      
                        |   | 36 |  | 
                      
                        |   | 37 |   == 1.2 SYF et VHDL == | 
                      
                        |   | 38 |  | 
                      
                        |   | 39 | Afin de décrire de tels automates, on utilise un style particulier de description VHDL qui définit l'architecture '''"fsm"''' (finite-state machine). | 
                      
                        |   | 40 | Le fichier correspondant possède également l'extension fsm. A partir de ce fichier, l'outil SYF effectue la synthèse d'automate et transforme cet automate abstrait en un réseau booléen. | 
                      
                        |   | 41 | '''SYF ''' génère donc un fichier VHDL au format vbe. | 
                      
                        |   | 42 | Comme la plupart des outils utilisés au laboratoire, il faut positionner certaines variables d'environnement avant d'utiliser '''SYF'''. | 
                      
                        |   | 43 | Pour les connaître, reportez-vous au man de syf. | 
                      
                        |   | 44 |  | 
                      
                        |   | 45 |   == 1.3 Exemple == | 
                      
            
                      
                        | 158 |   |  | 
                      
                        | 159 |   | = 4 Réalisation du compteur = | 
                      
                        | 160 |   |  | 
                      
                        | 161 |   |  | 
                      
                      
                        |   | 129 |   == 1.4 Synthèse logique == | 
                      
                        |   | 130 |  | 
                      
                        |   | 131 | La synthèse logique permet d'obtenir une netlist de portes à partir d'un réseau booléen (format .vbe).  | 
                      
                        |   | 132 | Plusieurs outils sont disponibles : | 
                      
                        |   | 133 |  | 
                      
                        |   | 134 |      * L'outil '''BOOM''' permet l'optimisation de réseau booléen avant synthèse. | 
                      
                        |   | 135 |      * L'outil '''BOOG''' offre la possibilité de synthétiser une netlist en utilisant une bibliothèque de cellules précaractérisées telle que '''SXLIB'''. | 
                      
                        |   | 136 | La netlist peut être soit au format '''.vst''' soit au format '''.al'''. | 
                      
                        |   | 137 | Vérifier la variable d'environnement '''MBK_OUT_LO=vst'''. | 
                      
                        |   | 138 | Pour plus de renseignements sur ces outils, reportez vous au man. | 
                      
                        |   | 139 |  | 
                      
                        |   | 140 |   == 1.5 Résolution des problèmes de fanout (sortance) == | 
                      
                        |   | 141 |  | 
                      
                        |   | 142 | Les netlists générées contiennent parfois des signaux internes attaquant un nombre important de portes (grand fanout). | 
                      
                        |   | 143 | Ceci se traduit par une détérioration des fronts (rise time et fall time). | 
                      
                        |   | 144 | Il y a alors une perte en performance temporelle. | 
                      
                        |   | 145 | Afin de résoudre ces problèmes, l'outil '''LOON''' remplace les cellules ayant un fanout (i.e sortance) trop grand par des cellules plus puissantes ou bien insère des buffers. | 
                      
                        |   | 146 |  | 
                      
                        |   | 147 |   == 1.6 Visualisation de la chaîne longue == | 
                      
                        |   | 148 |  | 
                      
                        |   | 149 | A tout moment, les netlists peuvent être éditées graphiquement. L'outil '''XSCH''' permet de visualiser le chemin le plus long grâce aux fichiers '''.xsc''' et '''.vst''' générés à la fois par '''BOOG''' et par '''LOON'''. | 
                      
                        |   | 150 |  | 
                      
                        |   | 151 | [[Image(T_RC.jpg,nolink)]] | 
                      
                        |   | 152 |  | 
                      
                        |   | 153 | La résistance équivalente R de la figure  est calculée sur la totalité des transistors du AND appartenant au chemin actif. | 
                      
                        |   | 154 | De même, la capacité C est calculée sur les transistors passants du NOR correspondant au chemin entre i0 et la sortie de la cellule. | 
                      
                        |   | 155 |  | 
                      
                        |   | 156 |   == 1.7 Vérification de la netlist == | 
                      
                        |   | 157 |  | 
                      
                        |   | 158 | La netlist doit être certifiée. | 
                      
                        |   | 159 | Pour cela, on dispose du simulateur '''ASIMUT'''. | 
                      
                        |   | 160 |  | 
                      
                        |   | 161 | = 2. Travail à faire = | 
                      
                        |   | 162 |  | 
                      
                        |   | 163 |   == 2.1 Réalisation du compteur == | 
                      
            
                      
                        | 180 |   |  | 
                      
                        | 181 |   | = 6 Automate pour digicode = | 
                      
                        | 182 |   |  | 
                      
                        | 183 |   |  | 
                      
                        | 184 |   | L'exemple qui suit servira dans toute la suite du TP. On veut réaliser une puce | 
                      
                        | 185 |   | pour digicode . Les spécifications sont les suivantes : | 
                      
                        | 186 |   |  | 
                      
                        | 187 |   |  | 
                      
                        | 188 |   |  | 
                      
                        | 189 |   | Les chiffres de 0 à 9 sont codés en binaire naturel sur | 
                      
                        | 190 |   | la manière suivante : | 
                      
                      
                        |   | 178 |   == 2.2 Réalisation d'un automate pour digicode == | 
                      
                        |   | 179 |  | 
                      
                        |   | 180 |     === a. Spécification de l'automate === | 
                      
                        |   | 181 |  | 
                      
                        |   | 182 | L'exemple qui suit servira dans toute la suite du TP. | 
                      
                        |   | 183 | On veut réaliser une puce pour digicode. | 
                      
                        |   | 184 | Les spécifications sont les suivantes : | 
                      
                        |   | 185 |  | 
                      
                        |   | 186 | Les chiffres de 0 à 9 sont codés en binaire naturel sur la manière suivante : | 
                      
            
                      
                        | 222 |   |  | 
                      
                        | 223 |   | = 7 Réalisation du digicode = | 
                      
                        | 224 |   |  | 
                      
                        | 225 |   | Dessiner le graphe d'états de l'automate. (Les corrections seront distribuées) | 
                      
                        | 226 |   | Le décrire au format .fsm .  Le synthétiser avec SYF en utilisant les options de codage '''-a''', '''-j''',''','''-m''', '''-o''', '''-r''' et en | 
                      
                        | 227 |   | utilisant les options -CEV. | 
                      
                      
                        |   | 214 |     === b. Travail à faire === | 
                      
                        |   | 215 |  | 
                      
                        |   | 216 | * Dessiner le graphe d'états de l'automate. (Les corrections seront distribuées) | 
                      
                        |   | 217 | * Le décrire au format .fsm . | 
                      
                        |   | 218 | * Le synthétiser avec SYF en utilisant les options de codage '''-a''', '''-j''',''','''-m''', '''-o''', '''-r''' et en utilisant les options -CEV. | 
                      
            
                      
                        | 233 |   | Ecrire le fichier .pat de vecteurs de test. | 
                      
                        | 234 |   |   * Simuler avec '''ASIMUT''' toutes les vues comportementales obtenues. | 
                      
                        | 235 |   |   * Adaptez le Makefile pour qu'il couvre tous les encodages possibles. | 
                      
                        | 236 |   |  Quelles sont vos remarques concernant la complexité des expressions (i.e temps) | 
                      
                        | 237 |   | et le nombre de registres (i.e surface) des descriptions comportementales suivant | 
                      
                        | 238 |   | les encodages ? En déduire les deux groupes d'encodage. | 
                      
                        | 239 |   |  Comparer aussi leurs nombres de littéraux. | 
                      
                        | 240 |   |  | 
                      
                      
                        |   | 224 | * Ecrire le fichier .pat de vecteurs de test. | 
                      
                        |   | 225 | * Simuler avec '''ASIMUT''' toutes les vues comportementales obtenues. | 
                      
                        |   | 226 | * Adaptez le Makefile pour qu'il couvre tous les encodages possibles. | 
                      
                        |   | 227 |  | 
                      
                        |   | 228 | Quelles sont vos remarques concernant la complexité des expressions (i.e temps) et le nombre de registres (i.e surface) des descriptions comportementales suivant les encodages ? | 
                      
                        |   | 229 | En déduire les deux groupes d'encodage. | 
                      
                        |   | 230 | Comparer aussi leurs nombres de littéraux. | 
                      
                        |   | 231 |  | 
                      
                        |   | 232 |   == 2.3 Optimisation du réseau booléen == | 
                      
                        |   | 233 |  | 
                      
                        |   | 234 | * Lancer l'optimisation booléenne avec l'outil '''BOOM''' en demandant une optimisation en surface puis en délai. | 
                      
                        |   | 235 |  | 
                      
                        |   | 236 | {{{ | 
                      
                        |   | 237 | >boom -V <vbe_source> <vbe_destination> - | 
                      
                        |   | 238 | }}} | 
                      
                        |   | 239 |  | 
                      
                        |   | 240 | * Essayer '''BOOM''' avec les différents algorithmes '''-s''', '''-j''', '''-b''', '''-g''', '''-p'''... | 
                      
                        |   | 241 | Le mode et le niveau d'optimisation sont aussi à changer. | 
                      
                        |   | 242 |  | 
                      
                        |   | 243 | * Comparer le nombre de littéraux après factorisation. | 
                      
                        |   | 244 |  | 
                      
                        |   | 245 |   == 2.4 Mapping sur cellules précaractérisées == | 
                      
                        |   | 246 |  | 
                      
                        |   | 247 | Pour chacun des réseaux booléens obtenus précédemment : | 
                      
                        |   | 248 | * Positionner les variables d'environnement ; | 
                      
                        |   | 249 | * Synthétiser la vue structurelle : | 
                      
                        |   | 250 |  | 
                      
                        |   | 251 | {{{ | 
                      
                        |   | 252 | >boog <vbe_source> - | 
                      
                        |   | 253 | }}} | 
                      
                        |   | 254 |  | 
                      
                        |   | 255 | * Lancer '''BOOG''' sur les différentes netlists pour observer l'influence des options de '''SYF''' et de '''BOOM''' ; | 
                      
                        |   | 256 | * Valider le travail de '''BOOG''' en resimulant avec '''ASIMUT''' les netlists obtenues avec les vecteurs de test qui ont servi à valider le réseau booléen initial. | 
                      
                        |   | 257 |  | 
                      
                        |   | 258 |   == 2.5 Visualisation de la netlist == | 
                      
                        |   | 259 |  | 
                      
                        |   | 260 | La chaîne longue est décrite dans le fichier '''.xsc''' produit par '''BOOG'''. L'outil '''XSCH''' l'utilisera pour colorer son chemin. | 
                      
                        |   | 261 | Pour lancer l'éditeur graphique : | 
                      
                        |   | 262 |  | 
                      
                        |   | 263 | {{{ | 
                      
                        |   | 264 | >xsch -I vst -l <vst_source> - | 
                      
                        |   | 265 | }}} | 
                      
                        |   | 266 |  | 
                      
                        |   | 267 | La couleur rouge désigne le chemin critique. | 
                      
                        |   | 268 | Si vous utilisez l'option '-slide' qui permet d'afficher un ensemble de netlists, n'oubliez pas d'appuyer sur les touches '+' ou '-' pour éditer vos fichiers ! | 
                      
                        |   | 269 |  | 
                      
                        |   | 270 |   == 2.6 Optimisation de la netlist == | 
                      
                        |   | 271 |  | 
                      
                        |   | 272 | Pour toutes les vues structurelles obtenues précédemment : | 
                      
                        |   | 273 | * Lancer '''LOON''' avec la commande : | 
                      
                        |   | 274 |  | 
                      
                        |   | 275 | {{{ | 
                      
                        |   | 276 | >loon <vst_source> <vst_destination> <lax_param> - | 
                      
                        |   | 277 | }}} | 
                      
                        |   | 278 |  | 
                      
                        |   | 279 | * Effectuer une optimisation de fanout en modifiant le facteur de fanout dans le fichier d'option '''.lax'''. | 
                      
                        |   | 280 | Imposer des valeurs de capacités sur les sorties. | 
                      
                        |   | 281 |  | 
                      
                        |   | 282 |   == 2.7 Vérification de la netlist == | 
                      
                        |   | 283 |  | 
                      
                        |   | 284 | À effectuer sur la meilleure  de vos netlists (justifiez votre choix !) : | 
                      
                        |   | 285 | * Valider le travail de '''LOON''' en resimulant sous '''ASIMUT''' les netlists obtenues avec les vecteurs de test qui ont servi à valider la vue comportementale initiale. | 
                      
                        |   | 286 | * Mettre les différents résultats (surface/temps/optimisation) dans votre rapport. | 
                      
                        |   | 287 | * Quelle est, selon vous, la meilleure des netlists ? Pourquoi ? |