Chapitre 3 - Bloc 2

Chapitre 3: Architecture type
d’une plate-forme pour

systèmes embarqués
Bloc 2: Bloc matériel/

Introduction à la synthèse de
haut niveau
INF3610 Systèmes embarqués 1

Plan
1. Flot de conception avec Vivado HLS

2. Trois types de pragma (les plus utilisés)
3. Comment interfacer avec le monde extérieur
4. Etudes de cas

Plan

4. Etudes de cas

Flôt de conception Vivado HLS
N.B. Directive = Pragma

Et synthèse d’interface (qu’on
va détailler plus loin)

En résumé
• À travers les 3 étapes de HLS (allocation, assignation et
ordonnancement) il faut aussi spécifier des directives (pragma)
– En fonction des requis de performance (e.g. ressources, débit, latence,
consommation de puissance, etc.), le concepteur doit fournir un
ensemble de pragma
• À titre d’exemples, voir:
– Lien disponible sur le site web:
https://www.xilinx.com/html_docs/xilinx2017_2/sdaccel_doc/topics/prag
mas/concept-Intro_to_HLS_pragmas.html

3 étapes importantes dans la
synthèse à haut niveau
(cas FPGA)
• Allocation : représente le matériel disponible: LUT, FF, unités
DSP et blocs RAM pour FPGA.
• Ordonnancement (scheduling) : consiste à assigner les
opérations aux étapes de contrôle.
• Assignation (binding): consiste à lier les opérations au
matériel disponible.
• N.B. On remarque ici qu’on est à un niveau d’allocation
beaucoup plus fin que pour un RISC (voir page suivante).
7
3 étapes importantes dans la
synthèse à haut niveau
(par analogie: cas du RISC)
• Allocation : représente le matériel disponible: e.g. à l’étape
EX comme par exemple unité entière, unités flottantes
pipelinées ou pas, unités de branchement, etc.
• Ordonnancement (scheduling) : consiste à assigner les
opérations aux étapes de contrôle (et en y incluant au besoin
des suspensions).
• Assignation (binding): consiste à lier les opérations au
matériel disponible, p.e. si j’ai 2 unités flottantes à quelle unité
j’assigne l’opération?
8
Plan

4. Etudes de cas

Présentation de 3 types de pragma
Ref. https://www.xilinx.com/html_docs/xilinx2017_4/sdaccel_doc/jit1504034365862.html
1) Déroulement de boucles:
#pragma HLS unroll
On assume Le pragma doit être dans la boucle
3 cycles pour respecter
les dépendances résultat
3 x 4 = 12 cycles
3 x 2 = 6 cycles

3 x 1 = 3 cycles
Autre exemple de déroulage de
boucles avec Vivado HLS
• Soit un algorithme en C qui fait la moyenne de 9 valeurs
d’un tableau obtenu en entrée:
– 9 additions pour trouver le total
– 1 multiplication by 1/9 pour faire la moyenne
• On veut d’abord optimiser la latence (nombre de cycles
necessaires pour produire la première sortie)
• Ici on va utiliser le déroulement de boucles

Autre exemple de déroulage avec
Vivado HLS
• Voici différentes façons de faire l’ordonnancement et
l’assignation et qui offrent différentes latences:
(1) Sans optimisation (e.g.

Vivado HLS cherche alors
à minimiser les ressources
(2) Déroulement partielle
(similaire à ce qu’on a fait
avec DLX)
on fait
tout (3) Déroulement complet
en un cycle Ici on utilise des unités
grâce au hard codés qui servent
DSP48E pour faire des MAC (mult/acc)
INF3610 Systèmes embarqués

DSP48E 12
2) Pipelinage de fonctions
#pragma HLS pipeline

Le pragma doit être dans la fonction

Autre exemple de pipeline de fonction
• Soit une fonction composée de 3 operations.

• En pipelinant les opérations sur 3 étages, on obtient une
accélération de 3.

Solution
non pipelinée

Solution
pipelinée

2) Pipelinage de boucles* (e.g. peut demander moins de ressource
que le déroulage de boucle)

Le pragma doit être au début du corps
de boucle
* On utilise aussi
le terme software
pipelining

À propos du pipelinage
• Soit l’expression X = (A + B + C) * (D + E + F) * G
• On suppose une contrainte de ressources de 2 Latence=4
additionneurs et 1 multiplieur
• La latence est de 4 cycles mais on
peut débuter un nouveau calcul à
toute les 2 cycles (-II = 2). On a
donc un nouveau résultat à tous les Débit=2
2 cycles (débit ou en anglais

throughput)

À propos du pipelinage
Latence=4
Débit =1
etc.
Avec 4 unités fonctionnels +/- et 2 unités de * on garde la même latence,
mais on a un résultat à chaque cycle à partir de 5 (II=1)
INF3610 - Systèmes embarqués 19

3) Partitionnement de tableau
shift_reg
#pragma HLS ARRAY_PARTITION variable=shift_reg complete dim=0

Plan

4. Etudes de cas

Comment interfacer avec le monde extérieur
(avec autres composants PL et aussi PS)
• Dans la conception basée sur C, toutes les opérations
d'entrée et de sortie sont effectuées, en un temps nul,
via des arguments de fonction formels.
• Dans une conception RTL, ces mêmes opérations

d'entrée et de sortie doivent être effectuées via un
port dans l'interface de conception et fonctionnent
généralement en utilisant un protocole d'E / S
(entrée-sortie) spécifique.

Pragma
Interface
Interface du lab 2

https://www.xilinx.com/html_docs/xilinx2017_4/sdaccel_doc/jit1504034365862.html

https://www.xilinx.com/html_docs/xilinx2017_4/sdaccel_doc/jit1504034365862.html
Plan

4. Etudes de cas

Étude de cas: FIR
(Finite Impulse Response)
• L’exemple provient d’un tutorial donné à Cornell:
– Lien disponible sur le site web:
http://www.csl.cornell.edu/courses/ece5775/pdf/lecture02.pdf

Étude de cas: FIR
Bleu: signal bruité en entrée

qui provient d’un
vecteur x[].
Rouge: signal filtré en sortie

mis dans un vecteur
y[].
Role possible d’un filtre:

enlever du bruit
Étude de cas: FIR
Comment on fait ça?
Portion non filtrée Portion filtrée
1ère fenêtre
2e fenêtre
3e fenêtre
Filtrage
• Soit n=3:
o C’est comme si on avait une fenêtre de 3 points qui se déplace de droite à gauche.
o Chaque fenêtre fait une multiplication/accumulation sur 3 points (sorte de moyenne) et
o remplace le point milieu par ce résultat.
Étude de cas: FIR
De manière plus générale:
Entrée
Sortie
Filtre FIR avec n points
Pseudo code du FIR
Soit un tableau x de n points:
1. on décale à droite (1 shift)
2. on lit un nouveau point en x[0]
3. on fait la multiplication/accumulation i.e.
4. on met le résultat de 3) dans un tableau résultat y et on retourne à 1.
29
Étude de cas: FIR
De manière plus générale:
Ici la fenêtre
x[0] x[1] x[n] est fixe et les points
Entrée circulent de gauche à droite,
Donc avec un décalage à droite
de 1 à chaque opération
Sortie
Filtre FIR avec n points
Pseudo code du FIR
Soit un tableau x de n points:
1. on décale à droite i.e. 1 shift (et le point le plus à droite est perdu)
2. on lit un nouveau point en x[0]
3. on fait la multiplication/accumulation i.e.
4. on met le résultat de 3) dans un tableau résultat y et on retourne à 1.
30
Étude de cas: FIR
Solution séquentielle
N.B. Ici x est shift register

//décalage
et y est output
//on lit un nouveau point
//mult/add
//affectation à y

Étude de cas: FIR
• Résultat de synthèse (solution séquentielle
avec pragma) Iteration Latency: nombre de cycles pour réaliser 1 iteration de la boucle
Au total
Latence
Pour la boucle de mult/acc
11*3=33
Ressources
Attention mon exemple

contient 11 poids et non 10
comme l’algo de la page précédente

Étude de cas: FIR
Peut-on faire mieux en déroulant les boucles?

Étude de cas: FIR
Accès aux registres reste séquentiel
Parallélisation

Étude de cas: FIR

Étude de cas: FIR

Étude de cas: FIR
Ne peut pas toujours se faire en 1 cycle,

au moins log N ( avec Wallace tree)
Étude de cas: FIR
Exemple pour n=4 avec un arbre de sommation (Wallace tree).
On peut également pipeliner cette arborescence.

Étude de cas: FIR
• Résultat de synthèse (parallélisation + array
partitionning)
Au total
N.B. Accélération de 2 par rapport à séq.
Latence

Ne s’applique pas ici car il n’y a plus de boucle
Ressources
N.B. Mais beaucoup plus de ressources que séq.

Ordonnancement avec unroll 14 cycles pour 11
mult/acc, on c’est pas
un déroulement parfait
(page 10):
Pourquoi?
Étude de cas: FIR
Existe-t-il un compromis entre les 2 solutions précédentes?
Réponse: oui!
Plutôt que de dérouler la boucle, allons y
avec le pipeline

Étude de cas: FIR

Multiplication
Accumulation
Décalage
Étude de cas: FIR
Multiplication
Accumulation
Décalage
Solution séquentielle
3 x 11
Solution pipelinée
INF3610 Systèmes embarqués 3 + 11 43
Étude de cas: FIR
Résultat de synthèse (pipeline + array partitionning)
Au total
N.B. Similaire au déroulement de boucle
II (débit demandé)
Latence

Ressources
11+3=14
N.B. Beaucoup moins de DSP que pour le déroulement

de boucles…

Étude de cas: FIR
Au cycle 3 on a:
1 2 3
• Accumulation de l’iteration 1
4
• Multiplication de l’itération 2
5
• Décalage de l’itération 3
Donc 3 operations sur

3 iterations différentes
Autre étude de cas: multiplication matricielle
n=m
n≠m
46
multiplication matricielle
Solution 1: sans optimisation

Solution 1: sans optimisation
Temps d’execution: O(n3)
Ressources matérielles O(1)

Solution 2: pipeline opération mult/acc
49
Dépendance de données

Ressources matérielles O(1)

Solution 3: pipeline la boucle Product
52
53
Dépendance de ressources
(structurelle)

• Trois solutions:
2) HLS ARRAY_PARTITION complet (solution 4)



• Quelle(s) difference(s) entre ARRAY_RESHAPE et

ARRAY_PARTITION?

• Retour à notre question:

• Quelle(s) difference(s) entre ARRAY_RESHAPE et
ARRAY_PARTITION?
• Rép.: un ARRAY_RESHAPE est comme un garbage
collector, on dit qu’il est constitué d’un
ARRAY_PARTITION suivi d’un ARRAY_MAP
• Remarque: lorsqu’on fait un ARRAY_RESHAPE ce ne
serait pas préférable de mettre toujours complet?

Solution 5: pipeline la boucle Product avec ARRAY_PARTITION
• On voit pas tout sur le
schéma mais il manque 2
blocs de read donc un total
de 4 blocs par variables (a
et b). On utilize le port p0
de la BRAM.
• Chaque bloc a 32 bits de

large
(float is a 32 bit IEEE 754
single precision Floating
Point Number1 bit for the
sign, (8 bits for the exponent,
and 23* for the value), i.e.
float has 7 decimal digits of
precision).

Solution 6: pipeline la boucle Product avec ARRAY_RESHAPE
• On 1 bloc de read par
variables (a et b).
• Chaque bloc a 128 bits de

large (4 x 32)
(float is a 32 bit IEEE 754
single precision Floating
Point Number1 bit for the
sign, (8 bits for the exponent,
and 23* for the value), i.e.
float has 7 decimal digits of
precision).

Solutions 4 à 6: pipeline la boucle Product
Ressources matérielles O(n)

Ordonnancement
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

Similiture entre HLS pipeline et pipeline DLX
Adresse calculée
Condition de branchement
LI/DI DI/EX EX/MEM MEM/ER
4 M NCP Branche- Donnée à écrire en

U
X
Zéro? ment pris registre
ADD
C
P
RI[6:10]
M
A U
Mémoire RI[11:15]
X
RI M
instruc- U
tions Registres Mémoire X
UAL données Valeur chargée
B Adresse
MEM/ER (DMC)
M
U
X
Donnée à écrire
Imm
Étendre
RI[16:31]
RI[0:5] Instruction Instruction
64
Donnée à écrire en
registre
Ordonnancement
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
Ai1
B1j
Ai2
B2j
pipeline de
la page 54
Ai3
B3j
Ai4
B4j
On a donc bien 4 lectures en simultanée (cycles 1, 6, 11 et 16) Resultat

P.S. On suppose qu’on a des registres entre chaque étage 65 final
INF3610 - Systèmes embarqués
Solution 7: pipeline les boucles Col et Product
66
67
Temps d’execution: O(n)
Ressources matérielles O(n2)

Solution 8: pipeline les boucles Row, Col et Product (donc la
fonction complète)
Est-ce possible?
69
Temps d’execution: O(1)
Ressources matérielles O(n3)
Réponse: oui mais pas sur une Zedboard

INF3610 - Systèmes embarqués
⇒ $$$ 70
Autre cas: opération scalaire sur un tableau x
(similaire à l’exemple vu pour le DLX)
for (i=1; i<=1000; i++)
X[i] = X[i] + S;
#pragma HLS_pipeline
for (i=1; i<=1000; i++)
read X;
Add;
write X;
• À partir du cycle 3 on termine une

iteration de boucle à tous les
cycles i.e. II=1
• Notez aussi qu’à partir du cycle 3

on a deux operations mémoire par
cycle. Que se passe-t-il si on a pas
2 accès/cycle possible à la
mémoire? 71
Autre cas: opération scalaire sur un tableau x
(similaire à l’exemple vu pour le DLX)
for (i=1; i<=1000; i++)
X[i] = X[i] + S;
#pragma HLS_pipeline
for (i=1; i<=1000; i++)
read X;
Add;
write X;
Si on a pas 2 accès/cycle?
Réponse:
On voit que le debit II > 1
I.e. qu’on ne termine plus une iteration
par cycle…
Cette degradation est due à ce qu’on
appelle une dépendance structurelle!
P.S. D’où l’importance du
array_partititionning… 72
Autre cas: variante possible de l’opération scalaire sur des tableaux
for (i=1; i<=1000; i++) for (i=1; i<=1000; i++)
X[i] = Y[i] + S; read X;
Y[i] = X[i] + S; read Y
Add 1;
Add 2;
write X;
write Y
À partir du cycle 6 on a
deux operations
mémoire par cycle. Ici
pour permettre II=1 il
nous faut 4 operations
mémoires
simultanémment et 2
additions simultanées.
73
75
Autre cas: variante possible de l’opération scalaire avec dépendances de données
(mais cette fois avec unroll plutôt que pipeline)
X[1] = X[0] + S;
#pragma HLS unroll X[2] = X[1] + S;
for (i=1; i<=1000; i++)
for (i=1; i<=1000; i++) X[3] = X[2] + S;
X[i] = X[i-1] + S;
read X[i-1]; X[4] = X[3] + S;
Add; .
write X[i] On déroule la boucle
.
Il sera impossible d’avoir: X[1000] = X[999] + S;
Même problème de dépendance et on revient à une solution

séquentielle comme à la page précédente
76
Autre cas: variante possible de l’opération scalaire avec opérations flottantes

for (i=1; i<=1000; i++)
for (i=1; i<=1000; i++)
X[i] = X[i] + S;
read X;
On suppose une addition float
Add;
write X
Encore une fois, on ne peut avoir II = 1
77
Autre cas: variante possible de l’opération scalaire avec opérations flottantes

for (i=1; i<=1000; i++)
for (i=1; i<=1000; i++)
X[i] = X[i] + S;
read X;
On suppose une addition sur
ADDF;
un float write X
• Mais rien n’empĉche ici de pipeliner l’addition

• Notez aussi qu’à partir du cycle 3 on a deux operations
mémoire par cycle. À partir de la, il nous faut donc 2 accès
simultanée à la mémoire?
78

Chapitre 3 - Bloc 2

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Chapitre 3 - Bloc 2

Transféré par

Droits d'auteur :

Formats disponibles

Chapitre 3: Architecture type

d’une plate-forme pour

Bloc 2: Bloc matériel/

INF3610 Systèmes embarqués 1

1. Flot de conception avec Vivado HLS

INF3610 Systèmes embarqués 2

1. Flot de conception avec Vivado HLS

INF3610 Systèmes embarqués 3

N.B. Directive = Pragma

INF3610 Systèmes embarqués 4

INF3610 Systèmes embarqués 5

INF3610 Systèmes embarqués 6

1. Flot de conception avec Vivado HLS

INF3610 Systèmes embarqués 9

INF3610 Systèmes embarqués 10

INF3610 Systèmes embarqués 11

(1) Sans optimisation (e.g.

INF3610 Systèmes embarqués

#pragma HLS pipeline

INF3610 Systèmes embarqués 13

• Soit une fonction composée de 3 operations.

INF3610 Systèmes embarqués 14

INF3610 Systèmes embarqués 15

INF3610 Systèmes embarqués 16

#pragma HLS pipeline

INF3610 Systèmes embarqués 17

2 cycles (débit ou en anglais

INF3610 Systèmes embarqués 18

INF3610 - Systèmes embarqués 19

#pragma HLS ARRAY_PARTITION variable=shift_reg complete dim=0

INF3610 Systèmes embarqués 20

1. Flot de conception avec Vivado HLS

INF3610 Systèmes embarqués 21

• Dans une conception RTL, ces mêmes opérations

INF3610 - Systèmes embarqués 22

INF3610 - Systèmes embarqués 23

INF3610 - Systèmes embarqués 24

1. Flot de conception avec Vivado HLS

INF3610 Systèmes embarqués 25

INF3610 Systèmes embarqués 26

Bleu: signal bruité en entrée

Rouge: signal filtré en sortie

Role possible d’un filtre:

N.B. Ici x est shift register

INF3610 Systèmes embarqués 31

Pour la boucle de mult/acc

Attention mon exemple

INF3610 - Systèmes embarqués 32

INF3610 Systèmes embarqués 33

Accès aux registres reste séquentiel

INF3610 Systèmes embarqués 34

INF3610 Systèmes embarqués 35

INF3610 Systèmes embarqués 36

Ne peut pas toujours se faire en 1 cycle,

INF3610 Systèmes embarqués 38

Pour la boucle de mult/acc

N.B. Mais beaucoup plus de ressources que séq.

INF3610 - Systèmes embarqués 39

INF3610 Systèmes embarqués 41

INF3610 Systèmes embarqués 42

Pour la boucle de mult/acc

N.B. Beaucoup moins de DSP que pour le déroulement

INF3610 - Systèmes embarqués 44

Donc 3 operations sur