La conception de circuit synchrones en Esterel v7 Gérard Berry Chaire Algorithmes, machines et...

La conception de circuit synchronesen Esterel v7

Gérard Berry

Chaire Algorithmes, machines et langages

Collège de France

Cours 5, 14 mai 2013

2G. Berry, Collège de France 14/05/2013

Micro-architecture

Architecture

Circuits

Design logique RTL

DFT (testabilité)

PlacementRoutage

Masks$ 1,000,000

Design

Synthèse

Vérification

Micro-architecture

Architecture

Circuits

Design logique RTL

DFT (testabilité)

PlacementRoutage

Masks$ 1,000,000

Micro-architecture

Architecture

Circuits

Design logique RTL

DFT (testabilité)

PlacementRoutage

Masks$ 1,000,000

ESTEREL V7

5G. Berry, Collège de France

• Définir un langage de naut niveau– pour écrire des circuits de façon comportementale (?)– en traitant chemins de données + chemins de contrôle

14/05/2013

Objectifs

• Ecrire des compilateurs / simulateurs efficaces – pour que les architectes fassent tourner les designs – très tôt dans le cycle de développement– avec des outils perfectionnés de visualisation et débogage– pour générer des circuits aussi bon qu’à la main – en garantissant une parfaite identité exécution / simulation

• Se connecter aux meilleurs moteurs de vérification– Pour vérifier le maximum de propriétés avant l’exécution– Et donc trouver les bugs très tôt dans le développement

G. Berry, Collège de France

• 1990 : Esterel v5 circuits (cf cours 4, 23/04/2013)

• ~1995 : Joe Buck de Synopsys intègre Esterel v5 dans Cocentric System Studio, pour le design haut niveau de systèmes électroniques

• ~1996 : Luciano Lavagno et Ellen Sentovich de Cadence intègrent Esterel dans Polis, HW/SW Codesign, puis développent ECL = Esterel C Language

14/05/2013 6

Esterel v7 : la genèse

• ~1998 : Michael Kisninevsky (Intel Strategic CAD Lab, Portland, Oregon) expérimente Esterel pour le design de circuits de contrôle

• ~1998 : Yves Leduc / Gaël Clavé expérimentent Esterel v5 chez Texas Instruments

• ~2000 : design préliminaire d’Esterel v7 avec M. Kishinevsky

• 2000-2001 : Création d’Esterel Technologies – Objectif : développer Esterel v7 / Esterel Studio pour les applications

logicielles et matérielles– Clients Dassault Aviation, Thomson, Texas Instruments, etc.– Intel Capital + Caisse des dépôts + VCs

14/05/2013 7

Esterel v7 : le démarrage

• 2003: Esterel Technologies rachète SCADE et décide la partition Esterel circuits / SCADE logiciels embarqués

• 2004-2009 : améliorations techniques, utilisation sur produits complexes en production

• 2007 : travail de standardisation IEEE

• 2001-2004 : développement du langage, du compilateur et du vérifieur, intégrés dans Esterel Studio; expérimentations clients (TI, ST Micro, Xilinx, Philips NXP, Intel)

• 2007 : filiale séparée Esterel EDA Technologies Coopération avec Synfora (Pico), Coware (SystemC)

14/05/2013 8

Esterel v7 : la maturité

• 2008 : développement de SCADE 6 chez E. T.

• 2008 : crise financière, TI licencie massivement

• 2009 : Esterel EDA ferme Esterel v7 Synfora

• 2011 : Synopsys rachète Synfora• 2009 : Esterel v7 Synopsys

• 2012 : Ansys rachète Esterel Technologies• 2009 : SCADE 6 en pleine forme !

• Définitions de données– en v5, données purement abstraites (APIs)– en v7, données paramétriques, précises et optimisées – pour la synthèse et la vérification, tableaux, bitvecteurs

14/05/2013 9

Esterel v7 : les nouveautés linguistiques

• Meilleure modularité– définitions d’ensembles de données– définitions d’interfaces (avec miroirs) et de modules– généricité (dimensions, fonctions, etc.)

• Enrichissement des signaux– mémorisés ou temporaires, avec ou sans valeurs initiales– immédiats ou retardés (registres)– tableaux de signaux et signaux à valeurs tableaux

G. Berry, Collège de France 14/05/2013 10

Esterel v7 : les nouveautés linguistiques

• Nouvelles instructions– équations simplifiant et standardisant le codage– boucles statiques de manipulation de tableaux– meilleur branchements des signaux meilleurs modules

• Manipulation d’horloges– masquage de cycles (clock gating)– vrai multi-horloge modulaire

La sémantique d’Esterel v5 est globalement préservéeet facilement étendue au clock-gating / multi-horloge

Project Structure

Automatic Documentation

ProjectManagement

Executable Specification

Exporter

Debugging & Simulation

Formal Verification

DesignVerification

Sequential Equivalence

Optimized for synthesis

DFT-ready

SystemC & RTL flow integrationSystemC RTL Synthesis

.sc .vhd

Architecture

Design Specification Capture

Design Functional

Spec Verification Requirements

ArchitectureDiagram

Editor

Simulator

DesignVerifier

ModelReporter

Code & TestbenchGenerators

Editor

SequentialEquivalence

Checker

PlayerIDE

• unsigned<N> : entiers positifs i tels que 0 i N1 (N élts.)

• unsigned<[N]> unsigned<2**N> (2N élts, N bits binaire)

14/05/2013 12

Entiers unsigned (2-adiques bien tronqués)

• Pourquoi cette précision ?– pour optimiser l’allocation des bus de données– 4 : unsigned<5> demande 3 fils– 5 : unsigned<6> demande 3 fils– mais 4*5 : unsigned<21> demande 5 fils, pas 6 !–pour vérifier statiquement l’indexation des tableaux

Regarder toutes les opérations dans le blanc des yeux,avec parfois de mauvaises surprises !

Opérations unsigned : unsigned<M>, unsigned<N> unsigned<MN1> car valeur max (M1)(N1) (MN1)1

: unsigned<M>, unsigned<N> unsigned<M> avec erreur si j i car valeur max (M1)0 M1 (erreur pour i j si i j)

* : unsigned<M>, unsigned<N> unsigned<(M1) (N1) 1> car valeur max (M 1) (N 1)

/ : unsigned<M>, unsigned<N> unsigned<M> car valeur max (M1) /1 (erreur si second argument nul)

mod : unsigned<M>, unsigned<N> unsigned<min(M,N1)> car valeur max M1 si M1 N2 et N2 sinon (erreur si second argument nul)

** : unsigned<M>, unsigned<N> unsigned<(M1)**(N1) 1>

car valeur max (M1)N1

Opérations unsigned

assert<M>(uexpr) : avec uexpr unsigned, déclare que la valeur v de uexpr vérifiera v M1 vérifié à la compilation, à la simulation ou formellement

<, <=, > , >=, =, <> : unsigned<M>, unsigned<N> bool, classiques

sat<M>(uexpr) avec uexpr : unsigned<M> : saturation à M1 soit v la valeur de uexpr. Alors sat<M>(uexpr) min(v,M1)

binsize (uexpr) : nombre de bits pour écrire uexpr en binaire

si la valeur de uexpr est v, le n tel que 2 n-1 v 2

• signed<N> : entiers i tels que N i N1 (2 N éléments)

• signed<[N]> signed<2**(N1)> (2N éléments, N bits en binaire)

14/05/2013 15

Entiers relatifs

- : signed<M> signed<M1> car valeur max (M)

abs : signed<M> unsigned<M1> car valeur max abs(M) M

: signed<M> signed<M> (unaire) identité

Opérations signed : signed<M>, signed<N> signed<MN> car valeur min MN

- : signed<M>, signed<N> signed<MN > car valeur max M1(N) (MN)1

* : signed<M>, signed<N> signed<MN 1 > car valeur max (M)(N)

/ : signed<M>, signed<N> signed<M1> car valeur max M / 1 si (erreur si second argument nul)

** : non introduit

mod : pas clair ! Pas de meilleure définition mathématique, on trouve toutes les définitions possibles selon les restes et signes ...

Opérations signed

assert<M>(sexpr) : avec sexpr signed, déclare que la valeur v de sexpr vérifiera M v M vérifié à la compilation, à la simulation ou formellement

sat<M>(sexpr) avec sexpr : signed<M> : saturation dans le sens du signe soit v la valeur de sexpr. Alors sat<M>(sexpr) v si M v M ou M si v M ou M1 si v M

Conversion automatique de signed en unsigned dans toutes les opérations mixtes

<, <=, > , >=, =, <> : signed<M>, signed<N> bool, classiques

: unsigned<M> signed<M> (unaire) car valeur max M1

: unsigned<M> signed<M1> (unaire) car valeur min (M1)

Tableauxtype Byte bool [8] ; // bitvector 0..7input Opcode : Byte ;

• indexation partielle : X [ i, j ] : Pixel [5] • extraction de sous-tableaux : X [1, 3..7] [2..5] : Pixel [5, 4]

type Pixel unsigned<256> ; // ou unsigned<[8]>, nombreconstant Size 100 : unsigned<> ; // implicit unsigned<101>output ImageStack : Pixel [Size,Size] [5] ;

Y : X [i, j] [ k1]

assert<Size>[ i ] & assert<Size>[ j ] & assert<5>[ k1] vérifié à la compilation, à la simulation ou formellement

• dimension évaluable statiquement, assertion de taille implicite

Bitvecteurs vecteurs de bits

• égalité , différence <>• B << k : shift gauche non signé• B >> k : shift droit non signé• B <<< k: shift gauche signé• B >>> k : shift droit signé

• concaténation : lcat(B0 , B1,..., Bn) et mcat(B0 , B1,..., Bn)

• extension à k bits : extend(B, k) et sextend(B, k)

• resize, reverse, etc.

type Byte bool [8] ; // bitvector 0..7input Opcode : Byte ;

type Word bool [32] ; // bitvector 0..31var Memory : Word [MemSize] in ... end

• constantes ’b010011

Cartes (maps) de bitvecteurs

Objectif : donner des synonymes intuitifs aux champs

map Word { // map non nommée LowByte [0..7] , LowHalf [0..15] , HighHalf [16..31]}; // définition séquentielle

map Instruction : Word seq {Opcode [8] ,Immediate , // boolRegister [7] ,Address [16]};

nom utile au débogage

map Instruction : Word { Opcode [0..7] , Immediate [8] , // bool RegisterNum [9..15] , Address [16..31]};

Conversion unsigned bitvecteurexpr : unsigned<M>

u2bin (expr) : bool [binsize(M1)] // écriture binaire minimaleu2bin (expr, N) : bool [N] // avec N binsize(M1)

bin2u (6) ’b110u2gray (6) ’b101u2onehot (6) ’b0000001 // 7 bits car 6 : unsigned<7>u2onehot (6, 10) ’b0000001000 // 10 bits, bit 6 à 1

u2code : possibilité pour l’utilisateur de définir son propre code

u2onehot (expr) : bool [M] // écriture un seul bit à 1u2onehot (expr, N) : bool [N] // avec N M

u2gray (expr) : bool [binsize(M1)] // écriture en code Grayu2gray (expr, N) : bool [N] // avec N binsize(M1)

Conversion bitvecteur unsigned

expr : bool [M]

bin2u (expr) : unsigned<[M]> // décodage binaire

bin2u (expr, N) : unsigned<N> // avec N 2M

gray2u (expr) : unsigned<[M]> // décodage Gray

gray2u (expr, N) : unsigned<N> // avec N 2M

onehot2u (expr) : unsigned<M> // décodage onehotonehot2u (expr, N) : unsigned<N> // avec N M

Conversions signed bitvecteur

expr : signed<M>

s2bin (expr) : bool [binsize(M1)1] // écriture binaire minimale

s2bin (expr, N) : bool [N] // avec N binsize(M1)1

s2bin (6) ’b0101s2bin (6) ’b1011

expr : bool [M]

bin2s (expr) : signed <[M]>

bin2s (expr, N) : signed <N> // avec N 2M-1

Signaux purs et valuésS : <statut, valeur> uniques dans l’instant (idem Esterel v5)Nouveau : reg (de Moore), temp (non mémorisé), initialisation

signal S1, // signal pur : statut mais pas de valeur

S2 : T, // signal valué : statut, valeur de type T mémorisée, S3 : // un émetteur au maximum à chaque instant

S3 : T combine F, // statut, valeur de type T mémorisée // émissions simultanées combinées par F

S4 : T init exp, // statut, valeur de type T mémorisée, S3 : // initialisée à la valeur de exp

S5 : T combine F init exp,

Valeurs simples, signaux temporaires

S8 : temp T, // statut, valeur non mémorisée, S3 : // un émetteur max.

S6 : value T, // pas de statut, valeur mémorisée, S3 : // un émetteur maximum à chaque instant

S7 : value T combine F, // pas de statut, valeur mémorisée // émetteurs multiples combinés par F

S9 : temp value T combine F init exp, // pas de statut, valeur combinée non mémorisée, // réinitialisation à chaque instant à la valeur de exp

Signaux retardés

R10 : reg, // statut retardé

R11 : reg T, // statut retardé, valeur de type T

R12 : reg value T combine F init exp,

?R10 : valeur émise à l’instant précédent

pre (?R10) non autorisé

Nouvelle instruction emitemit { S1, ?S2 <= 2, ?S3 <= 3 if X>0, next R10 if S4 and ?S4 > 0, next ?R11 <= pre(?S4)+?S5+2 if S6 }

every LR do emit StartStopCommand|| every UR do emit LapCommand

sustain { StartStopCommand <= LR, LapCommand <= UR}

Boucles sur tableaux

emit { O [0] <= I [0] , for i < M 1 do O [ i+1] <= O [ i ] or I [ i+1] end for}

OK pour la générationde circuits

I [0] I [1] I [2]

O [0] O [1] O [2]

Boucles sur tableaux

emit seq { O [0] <= I [0] , for i < M -1 doup O [ i+1] <= O [ i ] or I [ i+1] end}

Alternative : tableaux fonctionnels de SCADE 6

I [0] I [1] I [2]

O [0] O [1] O [2]

Mieux pour lasimulation logicielle

Exemple : un mini-filtre d’images TV

Etant donné un flot de pixels d’entrée xi ,

calculer un flot de pixels de sortie yi tels que

yi ( xi-2 4 xi-1 6 xi 4 xi+1 xi+2 ) / 16

• les pixels sont contenus dans des mots 32 bits• il faut laisser passer 2 pixels au démarrage

et les récupérer à la fin en complétant avec des 0

p0p1p2p3

*1 *4 *6 *4 *1

+ / 16

InWord : bool[32]

InPixel : temp unsigned<[8]>

OutPixel : unsigned<[8]>

Feeder BasicFilter

InWord Feeder InPixel BasicFilter OutPixel

OutEndOfLine

InEndOfLine

p0p1p2p3

*1 *4 *6 *4 *1

+ / 16

InWord : bool[32] OutPixel : unsigned<[8]>

Feeder BasicFilter

OutEndOfLine

InEndOfLine

Initialisation à 0

0 0 0 00

p0p1p2p3

*1 *4 *6 *4 *1

+ / 16

Feeder BasicFilter

OutEndOfLine

InEndOfLine

0 0 0 0

Entrée d’un mot, délai initial 2 cycles

p0p1p2p3

*1 *4 *6 *4 *1

+ / 16

Feeder BasicFilter

OutEndOfLine

InEndOfLine

Délai initial 2 cycles

p0p1p2p3

*1 *4 *6 *4 *1

+ / 16

Feeder BasicFilter

OutEndOfLine

InEndOfLine

Sortie du premier OutPixel

p0p1p2p3

*1 *4 *6 *4 *1

+ / 16

Feeder BasicFilter

OutEndOfLine

InEndOfLine

Sortie d’un OutPixel

p0p1p2p3

*1 *4 *6 *4 *1

+ / 16

Feeder BasicFilter

OutEndOfLine

InEndOfLine

Entrée d’un mot, sortie d’un OutPixel

p0p1p2p3

*1 *4 *6 *4 *1

+ / 16

Feeder BasicFilter

OutEndOfLine

InEndOfLine

p0p1p2p3

*1 *4 *6 *4 *1

+ / 16

Feeder BasicFilter

OutEndOfLine

InEndOfLine

p0p1p2p3

*1 *4 *6 *4 *1

+ / 16

Feeder BasicFilter

OutEndOfLine

InEndOfLine

Fin de ligne d’entrée, sortie d’un OutPixel

p0p1p2p3

*1 *4 *6 *4 *1

+ / 16

Feeder BasicFilter

OutEndOfLine

InEndOfLine

Entrée de 0, sortie d’un OutPixel

p0p1p2p3

*1 *4 *6 *4 *1

+ / 16

Feeder BasicFilter

OutEndOfLine

InEndOfLine

Entrée de 0, sortie OutPixel, fin de ligne de sortie

Groupes de données

data PixelData : constant PIXEL_WIDTH : unsigned<> = 8 ; // unsigned<9> type Pixel = unsigned <[ PIXEL_WIDTH ]> ; // un nombre!end data

data ImageData : constant LINE_LENGTH : unsigned<> = 8 ; constant NUMBER_OF_LINES : unsigned <> = 2 ;end data

data WordData :

constant WORD_WIDTH : unsigned<> = 32 ;

type Word = bool [WORD_WIDTH] ;

// un mot se décompose en 4 octets map Word { b0 [0..7], // bitvecteurs, pas nombres b1 [8..15], b2 [16..23], b3 [24..31] };end data

data InputLineData :

extends ImageData ; extends WordData ; extends PixelData ;

constant PIXELS_PER_WORD : unsigned<> = WORD_WIDTH / PIXEL_WIDTH ;

constant WORDS_PER_LINE : unsigned<> = LINE_LENGTH / PIXELS_PER_WORD ;end data

data FilterData :

constant Coef : unsigned<> [5]= {1, 4, 6, 4, 1} ;

// unsigned <7>

constant CoefSum : unsigned<> = 16 ;

constant INIT_DELAY : unsigned<> = 3 ;

end data

interface OutPixelIntf : extends PixelData ; output OutPixel : temp Pixel ; output OutEndOfLine ;end interface

interface WordIntf : extends WordData ; output Ready ; input InWord : Word ;end interface

interface InPixelIntf : extends PixelData ; input InPixel : temp Pixel ; input InEndOfLine ;end interface

//==========// Main module//==========

module Filter : extends WordIntf ; extends OutPixelIntf ;

signal extends InPixelIntf in // déclare tous les signaux de // InPixelIntf comme locaux run Feeder || run PixelFilter end signalend module

module Feeder :

// Interface declarationsextends InputLineData ;extends FilterData ;extends WordIntf ;extends mirror InPixelIntf ;

InWord / InPixel (?InWord.p0)

InPixel (?InWord.p2)

/ InPixel (?InWord.p3)/ EndOfWord

/ Ready …

/ InPixel(0)

WORDS_PER_LINE EndOfWord

2 InPixel / InEndOfLine

signal EndOfWord

module PixelFilter :

// Interface declarationsextends FilterData ;extends InputLineData ;

extends InPixelIntf ;extends OutPixelIntf ;

signal Product : unsigned<1531>[5] in // Compute Product array loop weak abort signal DelayLine : Pixel [5] init 0 in sustain { if InPixel then // décalage ?DelayLine [1..4] <= pre (?DelayLine [0..3]), ?DelayLine [0] <= ?InPixel end if }|| await INIT_DELAY InPixel ; sustain ?Product <= Coef [*] ?DelayLine // * sur tableaux end signal when InEndOfLine ; pause end loop

14/05/2013

signal Product : unsigned<1531>[5] in // Compute Product array loop weak abort signal DelayLine : Pixel [5] init 0 in sustain { if InPixel then // décalage ?DelayLine [1..4] <= pre(?DelayLine [0..3]), ?DelayLine [0] <= ?InPixel end if }|| await INIT_DELAY InPixel ; sustain ?Product <= Coef [*] ?DelayLine // * sur tableaux end signal when InEndOfLine ; pause end loop

14/05/2013

|| // Calcul des OutPixel sustain { ?OutPixel <= assert<[8]>((?Product [0] + ?Product [1] + ?Product [2] + ?Product [3] + ?Product [4]) / CoefSum) if Product ,

OutEndOfLine <= InEndOfLine }end signalend module

Registration des sorties

module PixelFilter :

// Interface declarationsextends FilterData ;extends InputLineData ;

extends InPixelIntf ;extends OutPixelIntf ;

Pas d’empilement des chemins critiques meilleure composition électrique

refine OutPixel : reg ;refine OutEndOfLine : reg ;

|| // Calcul des OutPixel sustain { next ?OutPixel <= assert<[8]>((?Product [0] + ?Product [1] + ?Product [2] + ?Product [3] + ?Product [4]) / CoefSum) if Product, next OutEndOfLine <= InEndOfLine }end signalend module

Accélération par pipeline

signal Product : reg unsigned<1531>[5] in // Compute Product array loop weak abort signal DelayLine : Pixel [5] init 0 in ...|| await INIT_DELAY InPixel ; sustain next ?Product <= Coef [*] ?DelayLine end signal when InEndOfLine ; pause end loop

Pour couper le chemin critique, insérer des registres entre produits et somme

Généricité

data PixelData : generic constant PIXEL_WIDTH : unsigned ; type Pixel = unsigned <[ PIXEL_WIDTH ]> ; // un nombre!end data

interface Intf : extends PixelData [ 16 / PIXEL_WIDTH ] input InPixel : Pixel // Pixel = unsigned<[16]> ; ...end interface

• Un langage riche et souple pour la conception de circuits synchrones (multi-horloges) complexes

• Qui rend triviales des opérations manuellement difficiles : séquence / parallèle / préemption, registration, pipelining, etc.

• Très amélioré et simplifié par la proposition de standardisation IEEE (merci aux participants)

• Mais maintenant apparemment en coma profond....

14/05/2013 59

Conclusion

Voir cours 6 pour l’implémentation et cours 2013-2014 pour le multi-horloges

Références

• The Esterel v7 Reference Manual Version v7.60 for Esterel Studio 6.1 Esterel EDA Technologies, Nov. 2008

• IEEE P1778™/D1 Draft Standard for Esterel v7 Language Reference Manual

La conception de circuit synchrones en Esterel v7 Gérard Berry Chaire Algorithmes, machines et...

Documents

Transcript of La conception de circuit synchrones en Esterel v7 Gérard Berry Chaire Algorithmes, machines et...

Esterel Implementation and Validation of Cruise Controller

Design of Embedded Systems: Models, Validation and ... · Introduction to Safe State Machines and Esterel Esterel Language Overview Esterel/SSM Pragmatics Interfacing with the Environment

Introduction à SCADEfrancois.touchard.perso.luminy.univ-amu.fr/INFO5/Langages/C3-SCADE… · Historique Esterel Technologies ... (proche des StateCharts)

Questions Des Machines Synchrones

Esterel Programming Language

The Synchronous Programming Model and Its Applciations Gérard Berry Chief Scientist Esterel Technologies Gerard.Berry@esterel-technologies.com.

ESUIF: An Open Esterel Compiler

“Software” Esterel Execution (work in progress)

CHAPITRE 6 COMPTEURS SYNCHRONES

Langages synchrones Lustre

Répartition modulaire de programmes synchrones

Esterel Primer

Programming Firebird Esterel Manual

Moteurs synchrones à réluctance assistée d’aimants › documentation_pdf › 5729_fr.pdf · 2 Dyneo+ moteurs synchrones à réluctance assistée d’aimants Dyneo+ moteurs synchrones

chap6compteur synchrones

Méthodologie UML et Langages Synchrones

Alternateurs Synchrones pour Centrales Hydroélectriques

Langages algébriques

Servomoteurs synchrones Série AM227..107

The ESTEREL synchronous programming language: design, … · 2020. 12. 30. · Title: The ESTEREL synchronous programming language: design, semantics, implementation Author: Gérard