La conception de circuit synchrones en Esterel v7 Gérard Berry Chaire Algorithmes, machines et langages Collège de France Cours 5, 14 mai 2013

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

Chips

Design

Synthèse

Fab

Vérification

Vérification

Vérification


Micro-architecture

Architecture

Circuits

Design logique RTL

DFT (testabilité)

PlacementRoutage

Masks$ 1,000,000

Chips

$$

$$

$$

$$

$$


Micro-architecture

Architecture

Circuits

Design logique RTL

DFT (testabilité)

PlacementRoutage

Masks$ 1,000,000

Chips

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

check

DUT

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

IDE

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

n


• 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

0 0 0

Délai initial 2 cycles



p0p1p2p3

*1 *4 *6 *4 *1

+ / 16


Feeder BasicFilter


OutEndOfLine

InEndOfLine

0 0

Sortie du premier OutPixel



p0p1p2p3

*1 *4 *6 *4 *1

+ / 16


Feeder BasicFilter


OutEndOfLine

InEndOfLine

Sortie d’un OutPixel

0



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

0



p0p1p2p3

*1 *4 *6 *4 *1

+ / 16


Feeder BasicFilter


OutEndOfLine

InEndOfLine

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

00



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

Documents

La conception de circuit synchrones en Esterel v7 Gérard Berry Chaire Algorithmes, machines et langages Collège de France Cours 5, 14 mai 2013