Architecture des systèmes numériques: arithmétique sur FPGA

• Addition signés/unsigned
• Le calcul en virgule fixe/flottante
• Multiplicateurs rapides
• DSP: filtre FIR et FFT
• FPGA - DSP/DSP/GPU

• STM32f4: ARM Cortex-M,

• CORE
• DSP
• FPGA:
• 1 euro -> 100 000 euros
• DSP
• SoC : System on Chip -> µP multi-cœurs ARM -> Traitement
image
 Tutoriaux: VHDL, ARM
VHDL, Projet Quartus, Simulation testbench ModelSim
Logique combinatoire/séquentielle
Datapath/FSM/Pipeline

Représentation data

Nombre entiers, A, n-bit, 𝐴 = 𝑎𝑛−1 ⋯ 𝑎0

• Unsigned integer: • signed integer: 0101, 1001
𝑛−1 𝑛−2

𝐴 = ෍ 𝑎𝑖 2𝑖 𝐴 = − ෍ 𝑎𝑖 2𝑖 𝑠𝑖 𝑎𝑛−1 = 1
𝑖=0 𝑖=0

• C2:
𝑛−2

𝐴 = −2𝑛−1 𝑎𝑛−1 + ෍ 𝑎𝑖 2𝑖
𝑖=0
 Unsigned integer Signed integer (C2)
000 0 0
001 1 1
010 2 2
011 3 3
100 4 -4
101 5 -3
110 6 -2
111 7 -1

0 2𝑛 − 1

−2𝑛−1 2𝑛−1 − 1
Représentation data
Nombre réel: virgule fixe ou flottante
virgule fixe
𝑛−1

𝐴 = ෍ 𝑎𝑖 2𝑖
𝑖=0

A = 1101.0101, n=4, unsigned fixed point

𝐴 = 20 × 1 + 21 × 0 + 22 × 1 + 23 × 1 + 2−1 × 0 + 2−2 × 1 + 2−3 × 0 + 2−4 × 1

1 1
𝐴 = 13 + + = 13.3125
4 16
Format 4.4: 4 bits pour la partie entière + 4 bits pour la partie fractionnaire (Format Q4.4)

3 2 1 0 -1 -2 -3 -4
1 1 0 1. 0 1 0 1
Représentation data

virgule fixe
 Représentation data IEEE-754: virgule flottante
virgule flottante
𝑠
𝐴 = −1 × 𝑚 × 2𝑒 IEEE-754: précision simple
m: mantisse codée n+1
e: exposant 𝑒 ∈ 𝑒𝑚𝑖𝑛 , 𝑒𝑚𝑎𝑥 : k-bit 1 bit 8 bits 23 bits
s: signe s e m

base: implicite (2)

IEEE-754: précision double

𝐴 = 1. 𝑎1 𝑎2 ⋯ 𝑎𝑛 : mantisse normalisée
𝐹𝑟𝑎𝑐𝑡𝑖𝑜𝑛 1 bit 11 bits 52 bit
s e m
𝐴 = 1. 𝑎1 𝑎2 ⋯ 𝑎𝑛 → 𝐴 = 1 + 𝑓
𝐹𝑟𝑎𝑐𝑡𝑖𝑜𝑛

13.3125 = 133125 × 10−4 → 𝑒 = −4, 𝑚 =133125

13.3125 = 0.133125 × 102 → 𝑒 = 2, 𝑚 =133125

 Représentation data IEEE-754: virgule flottante
virgule flottante
𝑠
𝐴 = −1 × 𝑚 × 2𝑒 IEEE-754: précision simple
m: mantisse codée n+1
e: exposant 𝑒 ∈ 𝑒𝑚𝑖𝑛 , 𝑒𝑚𝑎𝑥 : k-bit 1 bit k=8 bits n+1=23 bits
• Positif, négatif: C2, biaisée s e m
𝐴 = 1. 𝑎1 𝑎2 ⋯ 𝑎𝑛 → 𝐴 = 1 + 𝑓
𝐹𝑟𝑎𝑐𝑡𝑖𝑜𝑛
IEEE-754: précision double
𝒆𝒃 : exposant biaisée (stocké dans le processeur)
1 bit k=11 bits n+1 = 52 bit
𝑒𝑏 = 𝑒 − 𝑏, 𝑏 = 2𝑘−1 −1= 27 − 1 = 127: biais s e m

13.3125 = 133125 × 10−4 → 𝑒𝑏 = −4, 𝑚 =133125 (écriture mathématique)

13.3125 = 133125 × 10−4 → 𝑒 =? , 𝑚 =133125 (écriture machine)

𝑒𝑏 = −4 → 𝑒 = 𝑒𝑏 + 𝑏 = −4 + 127 = 123

𝑒 ∈ 0,255 , 𝑒𝑏 ∈ −127,128 ,
𝑏 = 127
 Représentation data IEEE-754: virgule flottante
virgule flottante
𝑠
𝐴 = −1 × 𝑚 × 2𝑒 IEEE-754: précision simple
m: mantisse codée n+1
e: exposant 𝑒 ∈ 𝑒𝑚𝑖𝑛 , 𝑒𝑚𝑎𝑥 : k-bit 1 bit k=8 bits n+1=23 bits
• Positif, négatif: C2, biaisée s e m
𝐴 = 1. 𝑎1 𝑎2 ⋯ 𝑎𝑛 → 𝐴 = 1 + 𝑓
𝐹𝑟𝑎𝑐𝑡𝑖𝑜𝑛

Valeurs spéciales −∞ 1 1111 1111 000…0 (f=0)

0 ∞ 0 1111 1111 000…0 (f=0)
= 𝑁𝑎𝑁 NaN 0 1111 1111 000…..100
0
0− 1 0000 0000 f=0
0+ 0 0000 0000 f=0
Représentation data
A = 15213.0 (float A) IEEE-754: virgule flottante

IEEE-754: précision simple

1 bit k=8 bits n+1=23 bits

s e m
0 10001100 11011011011010000…00000

l’écriture machine suivant le standard IEEE-754

15213.0 = 11101101101101
• Normalisé: A = 1 + 𝑚 = 1. 𝑚 → 1.1101101101101 × 213 (écriture mathématique) → 𝑒𝑏 = 13
• 𝑏 = 2𝑘−1 =127 (SP: simple precision)
• 𝑒 = 𝑒𝑏 + 𝑏 = 13 + 127 = 140 (exposant pour l’écriture machine)
Représentation data
SP: 00010100000101000000000000000000

SP: 0 0010 1000 00101000000000000000000

1 bit k=8 bits n+1=23 bits

s e m
0 00101000 001 0100 0000 0000 0000 0000

l’écriture machine suivant le standard IEEE-754

𝑒 = 𝑒𝑏 + 𝑏 = 40 → 𝑒𝑏 = 𝑒 − 𝑏 = 40 − 127 = −87
m = 001 0100 0000 0000 0000 0000 = 00101= 1 × 2−3 + 1 × 2−5 = 0.125 + 0.03125 = 0.15625

Normalisé: A = 1 + 𝑚 = 1.15625 × 2−87

Représentation data

Guerre du golfe, 1991

• Missile Scud (2000 m/s), anti-missile Patriot
• Codage clk 24 bits, echanti: 0.1 s
• 0.1s sur 24 bits -> erreur
• Erreur cumulée 100H: 0.34 s -> 700 m -> cible ratée

Fusée Ariane 5, 1996

• Explosion après 30 s
• IMU (Inertial Measurment System): accélération, vitesse
• Conversion float 64 bits (double) -> entier signé 16 bits
• Vitesse relative fausses

Bourse de Vancouver, 1982

• Valeur init 1000 CAD
• Arrondis -> Troncature
• 22 mois -> 520 CAD -> 1098 CAD
Addition
FPGA:
• conception/prototypage
• µC séquentiel, FPGA: concurrent, séquentiel
• FPGA parallèlisme
• Vitesse, FPGA (100 MHz), µC (200 MHz), Processeur (2 Ghz)
• 200 multiplications rapides (FPGA) -> 2GHz
• ECU, Robotique PLC (compter), IoT, Réseaux (Commutateur
GB)

Addition signée (C2) +7 0111 -7 1001 -7 1001

-7 1001 +6 0110 -4 1100 +7 0111
+4 0100 = 1101 = -3 (FAUX) = (1)0101 = (FAUX) = (1)0000 = (FAUX)
= 1101 = -3 (OK)

4 bits -> débordement

 Addition
Addition sur n bits:
• Half-Adder (HA)
• Full-Adder (FA)
• n-bit Adder: n FA

Ripple-Carry Adder (RCA)

r 0 0 1 0 0
Addition à propagation de la retenue
0 1 1 1 Complexité: O(n) linéaire
0 1 1 0 FPGA: Logique (carry chain)

s 0 1 0 1

RCA 6 bits
Addition
Carry Select Adder (CSA) Partitionner a et b en deux partie:
• aL + bL = sL + rL
• aH + bH = sH + rH

• Avantage: éviter le ripple

• Inconv: faire la même add 2 fois
• Complexité: O(log 2 𝑛) linéaire

𝑂 𝑛 =𝑛𝜖
𝑂 log 2 𝑛 = (log 2 𝑛) 𝜖

𝑛=8 𝑂 𝑛 =8𝜖
𝑂 log 2 𝑛 = 3𝜖
𝑛 = 128
𝑂 𝑛 = 128 𝜖
𝑂 log 2 𝑛 = 7𝜖
Addition

Carry LookAhead Adder (CLA) : add avec anticipation de la retenue Conclusion:

Additionneur ->compteur 1
Equation logique HA: 𝑠 = 𝑎⨁𝑏 𝑟 = 𝑎. 𝑏

Equation arithmétique HA: 𝑎 + 𝑏 = 2𝑟 + 𝑠

Equation logique FA: 𝑠 = 𝑎⨁𝑏⨁𝑐 𝑟 = 𝑎. 𝑏 + 𝑎. 𝑐 + 𝑏. 𝑐

Equation arithmétique HA: 𝑎 + 𝑏 + 𝑐 = 2𝑟 + 𝑠

anticipation de la retenue:
• Génération de la retenue seulement qd r=1
• Propagation optimale
Addition

Carry LookAhead Adder (CLA) : add avec anticipation de la retenue

𝑟𝑖+1 = 𝑎𝑖 . 𝑏𝑖 + 𝑎𝑖 . 𝑟𝑖 + 𝑏𝑖 . 𝑟𝑖

𝑖 = 2 → 𝑟3 = 𝑎2 . 𝑏2 + 𝑎2 . 𝑟2 + 𝑏2 . 𝑟2
n=32 bits -> 4 milliard de termes
𝑖 = 1 → 𝑟2 = 𝑎1 . 𝑏1 + 𝑎1 . 𝑟1 + 𝑏1 . 𝑟1 𝑐32

𝑟3 = 𝑎2 . 𝑏2 + (𝑎2 + 𝑏2 ). 𝑎1 . 𝑏1 + 𝑎1 . 𝑟1 + 𝑏1 . 𝑟1

𝑖 = 0 → 𝑟1 = 𝑎0 . 𝑏0 + (𝑎0 +𝑏0 ). 𝑟0

𝑟3 = 𝑎2 . 𝑏2 + (𝑎2 + 𝑏2 ). 𝑎1 . 𝑏1 + (𝑎1 +𝑏1 ). (𝑎0 . 𝑏0 + (𝑎0 +𝑏0 ). 𝑟0 )

 Addition

Carry LookAhead Adder (CLA) : add avec anticipation de la retenue

a b r s
0 0 0 c génération
1 1 1 c génération
0 1 c 𝑐ҧ propagation
1 0 c 𝑐ҧ propagation

a=b a c Génération (g)

𝑎≠𝑏 c 𝑐ҧ Propagation (p)

𝑝𝑖 = 𝑎𝑖 ⨁𝑏𝑖
𝑟𝑖+1 = 𝑔𝑖 + 𝑝𝑖 . 𝑟𝑖
𝑔𝑖 = 𝑎𝑖 . 𝑏𝑖 𝑠𝑖 = 𝑟𝑖 ⨁𝑝𝑖
Soustraction
𝑛−2 𝑛−2
Addition ->
𝐵 + 𝐵ത = 1111 ⋯ 1111 = −2𝑛−1 × 1 + ෍ 1 × 2𝑖 = −2𝑛−1 + ෍ 2𝑖 = −1
𝑖=0 𝑖=0
𝐴 − 𝐵 = 𝐴 + (−𝐵) 𝐵 + 𝐵ത = −1 → −𝐵 = 𝐵+1
ത (C2)