arithmétiques réelles sur fpga · iv remerciements blagues sur le gruyère à trous et, preuve...

N◦ d’ordre : 396

N◦ attribué par la bibliothèque : 06ENSL0 396

ÉCOLE NORMALE SUPÉRIEURE DE LYONLaboratoire de l’Informatique du Parallélisme

THÈSE

présentée et soutenue publiquement le 15 janvier 2007 par

Jérémie DETREY

pour l’obtention du grade de

Docteur de l’École Normale Supérieure de Lyon

spécialité : Informatique

au titre de l’École Doctorale de Mathématiques et d’Informatique Fondamentale de Lyon

Arithmétiques réelles sur FPGAVirgule fixe, virgule flottanteet système logarithmique

Directeurs de thèse : Florent DE DINECHINJean-Michel MULLER

Après avis de : Miloš D. ERCEGOVACDaniel ÉTIEMBLE

Devant la commission d’examen formée de :

Javier D. BRUGUERA MembreFlorent DE DINECHIN MembreMiloš D. ERCEGOVAC Membre/RapporteurDaniel ÉTIEMBLE Membre/RapporteurDominique LAVENIER MembreJean-Michel MULLER Membre

À Aurélie,pour son soutien et sa patience sans limite.

À mes parents,sans qui rien de tout cela ne serait arrivé.

À Cüneyt Arkın,source d’inspiration sans égale.

Remerciements

Je tiens tout d’abord à remercier Dominique Lavenier, directeur de recherche CNRS dansl’équipe Symbiose de l’IRISA à Rennes, pour avoir accepté de présider le jury lors de ma sou-tenance. Je remercie aussi Miloš D. Ercegovac et Daniel Étiemble pour avoir relu ce documentavec soin et pour leurs remarques pertinentes qui m’ont permis, j’espère, d’améliorer sa qualité etsa clarté. Je suis également grandement reconnaissant à Javier D. Bruguera pour bien avoir vouluêtre membre de mon jury.Je tiens bien évidemment à remercier tout aussi profondément mes deux directeurs de thèse,

Florent de Dinechin et Jean-Michel Muller, pour leurs grandes qualités d’encadrants et pour laconfiance qu’ils m’ont témoignée ces quatres dernières années. Merci à eux pour m’avoir consi-déré immédiatement comme un chercheur à part entière, me laissant l’entière liberté dans mes re-cherches, tout en étant disponibles à tout instant pour répondre à mes questions, pour me donnerdes conseils avisés ou bien encore pour m’encourager dans les moments de doute. Je les remercieenfin également pour avoir été non seulement des collègues mais aussi de véritables amis, avecqui j’ai pu passer des moments formidables.Je tiens aussi à remercier toute l’équipe administrative du projet Arénaire et plus généralement

du LIP, depuis les secrétaires du laboratoire (Danielle Bianchetti, Sylvie Boyer, Corinne Iafrate, Isa-belle Pera et Edwige Royboz) comme du département d’enseignement (Simone Durand et HélèneSchoch) jusqu’auxMoyens Informatiques (Dominique Ponsard et Serge Torres), sans oublier biensûr les administrateurs successifs des serveurs d’outils de synthèse FPGA (Florent de Dinechin,Jean-Christophe Mignot et Arnaud Tisserand). Un grand merci donc à elles et à eux pour avoirpris en charge toutes ces tracasseries administratives et techniques et m’avoir ainsi permis de meconcentrer sur mes travaux de recherche.Je tiens ensuite à remercier toutes celles et tous ceux que j’ai pu croiser durant ces quelques

années au LIP. À commencer par mes co-bureaux, qui ont su me supporter sans broncher : .sa;Ea:=+Ba etsa maîtrise toute particulière de la langue française1 ; Pascal et son accent qui sent bon l’Occitaniede ma jeunesse ; Kiki, toujours prêt à relever des défis de viande stupides ; Nico et Édouard, finsvététistes juste un poil trop cramés pour moi ; Sylvain et Christoph et leurs coups de gueule re-tentissants ; et enfin Ahmed et Ouassila, avec qui j’ai malheureusement moins eu le temps de faireconnaissance.Une pensée particulière aussi à tous les autres thésards du projet Arénaire (David, Francisco,

Guillaume et Guillaume, Romain et les inséparables Sylvie et Nicolas) et plus généralement duLIP (Anne, Antoine, Clément, Emmanuel, Loris, Stéphane, Victor, Vincent, ...). Et plein de courageà ceux d’entre eux qui attaquent la dernière ligne droite !Je tiens aussi à remercier tous les membres du projet Arénaire, pour avoir su entretenir une

ambiance conviviale et chaleureuse dans l’équipe. Merci donc à Claude-Pierre, Damien, Florent,Gilles, Jean-Michel, Nathalie, Serge, Sylvie et Vincent, ainsi qu’à Catherine, Ilia, Nono, Marc etPhilippe. Une mention toute particulière à Jean-Luc, pour avoir supporté toutes ces années mes

1ba;h;na;.ca;ea;d, mon cher ga;Ma;qU ! :)

iv Remerciements

blagues sur le gruyère à trous et, preuve qu’il n’est pas rancunier, pour m’avoir invité au Japon,ainsi qu’à Nicoras, pour la patience inépuisable dont il a su faire preuve avec moi, et ce malgré sesproblèmes d’étanchéité. Merci aussi à eux deux pour leur soutien constant, leurs bons conseils,leurs discussions passionnantes, leurs tranches de franche rigolade et, enfin et surtout, pour avoirété des amis sincères et formidables durant ces quelques années !Nombre de remerciements vont aussi à toutes ces personnes du LIP avec qui j’ai pu partager de

bons moments, au coin-café ou ailleurs. Ainsi merci à ce cher Docteur Jean-Daniel, avec qui avoirune discussion sérieuse exempte de calembour relève de l’impossible ; à Anne et Bob pour leursdélicieux whiskies ; à Fred et Jean-Christophe pour leurs goûts musicaux ; à Ray pour sa passionpour le cinéma alternatif. Merci aussi à Alain, Corinne, Dom, Eddy, Edwige, Hélène, Natacha,Serge, Sylvie, Tanguy, Tom, Yves ainsi qu’à celles et ceux que j’oublie.Je tiens aussi à remercier Jean-François Ponsignon, responsable de l’enseignement informa-

tique en premier cycle à l’INSA de Lyon où j’ai effectué mon monitorat. Un grand merci aussi àtous les étudiants de l’INSA comme de l’ENS qui ont réussi à me supporter en tant que TD-man !Et parmi ces étudiants, je remercie tout particulièrement Sylvain, Xavier et Loïc de m’avoir faitconfiance et d’avoir choisi de faire leur stage de première année encadrés par Florent et moi.Enfin, il me reste à remercier mes ami-e-s de l’ENS Lyon et de Fermat, soit, en vrac, Beubeu,

Bolo, Blaise, Didier, Enzo, François, Georges, Jérémie, Julien, Laurent, Manu, Manue, Nico, Pierre,Poudro, Samuel, Seco, Skub, Tinou, Tonio, Xavier, Yann, ainsi que toutes et tous mes camaradesrouges et noir-e-s qui se reconnaîtront.Pour conclure cette page de remerciements, je dois admettre qu’elle fut sans aucun doute la

partie la plus difficle à écrire de ce document. Tant de personnes sont à mentionner ici que lacrainte d’en oublier ne serait-ce qu’une m’a longtemps empêché de m’y atteler. C’est pourquoije tiens à terminer en présentant mes plus plates et confuses excuses à celles et ceux qui ne seretrouveront pas dans cette liste, qui est bien loin d’être exhaustive. Peut-être comprenez-vousmaintenant mon goût pour l’informatique et pour ces machines capables de pallier efficacement àma mémoire pas vraiment étanche. Merci à vous !

Table des matières

Introduction 1

1 Contexte 51.1 Notations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51.2 Arithmétique(s) réelle(s) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

1.2.1 Virgule fixe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61.2.2 Virgule flottante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91.2.3 Système logarithmique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

1.3 FPGA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211.3.1 Domaines d’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221.3.2 Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221.3.3 Programmation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281.3.4 Portabilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

2 Fonctions élémentaires en virgule fixe 312.1 Présentation de la méthode HOTBM . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

2.1.1 Évaluation de fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322.1.2 Approximation polynomiale par morceaux . . . . . . . . . . . . . . . . . . . . 342.1.3 Tirer parti de la symétrie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342.1.4 Calcul des termes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372.1.5 Élévation à la puissance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 402.1.6 Calcul du produit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

2.2 Adaptation de la précision . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 452.2.1 Moins de bits pour B . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 462.2.2 Élévation à la puissance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 472.2.3 Moins de bits pour A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

2.3 Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 522.3.1 Vue d’ensemble . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 522.3.2 Termes tabulés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 532.3.3 Termes puissance et produit . . . . . . . . . . . . . . . . . . . . . . . . . . . . 552.3.4 Élévation à la puissance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

2.4 Analyse d’erreur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 562.4.1 Approximation polynômiale : ǫpoly . . . . . . . . . . . . . . . . . . . . . . . . . 572.4.2 Adaptation de la précision : ǫmethod . . . . . . . . . . . . . . . . . . . . . . . . 582.4.3 Erreurs d’arrondis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 692.4.4 Combinaison de toutes les erreurs . . . . . . . . . . . . . . . . . . . . . . . . . 72

2.5 Résultats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 732.6 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74

vi Table des matières

2.6.1 Contribution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 742.6.2 Limitations et perspectives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

3 Opérateurs de base en virgule flottante et système logarithmique 773.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77

3.1.1 Nombres réels et FPGA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 773.1.2 Quelle arithmétique pour quelle application ? . . . . . . . . . . . . . . . . . . 773.1.3 Un outil pour une comparaison sans a priori . . . . . . . . . . . . . . . . . . . 78

3.2 Une bibliothèque d’opérateurs pour les nombres réels . . . . . . . . . . . . . . . . . . 783.2.1 Représentation des nombres . . . . . . . . . . . . . . . . . . . . . . . . . . . . 783.2.2 Opérateurs en virgule flottante . . . . . . . . . . . . . . . . . . . . . . . . . . . 803.2.3 Opérateurs en système logarithmique . . . . . . . . . . . . . . . . . . . . . . . 82

3.3 Compromis précision/coût/performance : quelle arithmétique pour quelle appli-cation ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 853.3.1 Comparaison des opérateurs isolés . . . . . . . . . . . . . . . . . . . . . . . . . 853.3.2 Détail de la méthodologie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 883.3.3 Quelques exemples de comparaisons au cas par cas . . . . . . . . . . . . . . . 88

3.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 943.4.1 Contribution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 943.4.2 Perspectives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

4 Fonctions élémentaires en virgule flottante 954.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 954.2 Logarithme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

4.2.1 Algorithme d’évaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 964.2.2 Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 974.2.3 Analyse d’erreur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 994.2.4 Résultats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100

4.3 Exponentielle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1024.3.1 Algorithme d’évaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1024.3.2 Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1044.3.3 Analyse d’erreur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1064.3.4 Résultats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107

4.4 Sinus et cosinus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1104.4.1 Algorithme d’évaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1104.4.2 Implémentation de référence . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1124.4.3 Implémentations dégradées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1154.4.4 Résultats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116

4.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1164.5.1 Contribution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1164.5.2 Perspectives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117

Conclusion 119

Liste des figures

1.1 Représentation en virgule fixe d’un nombreX . . . . . . . . . . . . . . . . . . . . . . 71.2 Axe des nombres représentables en virgule fixe . . . . . . . . . . . . . . . . . . . . . . 71.3 Comportement de l’erreur absolue de représentation en virgule fixe ǫabs

FXP(x) . . . . . 81.4 Comportement de l’erreur relative de représentation en virgule fixe ǫrel

FXP(x) . . . . . 91.5 Représentation en virgule flottante d’un nombre X . . . . . . . . . . . . . . . . . . . 101.6 Axe des nombres positifs représentables en virgule flottante . . . . . . . . . . . . . . 131.7 Comportement de l’erreur absolue de représentation en virgule flottante ǫabs

FP (x) . . . 141.8 Comportement de l’erreur relative de représentation en virgule flottante ǫrel

FP(x) . . . 141.9 Représentation dans le système logarithmique d’un nombre X . . . . . . . . . . . . . 161.10 Arrondi au plus proche dans le système logarithmique . . . . . . . . . . . . . . . . . 171.11 Arrondi fidèle dans le système logarithmique . . . . . . . . . . . . . . . . . . . . . . . 181.12 Axe des nombres positifs représentables dans le système logarithmique . . . . . . . 181.13 Comportement de l’erreur absolue de représentationdans le système logarithmique

ǫabsLNS(x) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

1.14 Comportement de l’erreur relative de représentation dans le système logarithmiqueǫrelLNS(x) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

1.15 Architecture générale d’un FPGA et détail d’un îlot . . . . . . . . . . . . . . . . . . . 231.16 Structure d’un îlot (CLB) sur Virtex-II . . . . . . . . . . . . . . . . . . . . . . . . . . . 241.17 Implémentation des fonctions booléennes F et G à 4 variables sur les deux LUT

d’un slice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251.18 Implémentation sur un slice d’une fonction booléenne F à 5 entrées en utilisant un

multiplexeur dédié . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261.19 Additionneur 2 bits implémenté sur un slice grâce à la chaîne de propagation de

retenue rapide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

2.1 Représentation de la fonction f(x) = log2(1 + x) sur l’intervalle I = [0, 1[ . . . . . . . 332.2 Découpage du mot d’entréeX en A et B . . . . . . . . . . . . . . . . . . . . . . . . . . 342.3 Représentation des termes T0, T1 et T2 pour la fonction f(x) = log2(1 + x) . . . . . . 352.4 Correspondance entre B et B∗ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372.5 Exemples de symétries paire (k = 2) et impaire (k = 1) . . . . . . . . . . . . . . . . . 382.6 Représentation des termes T ′

0, T′1 et T

′2 pour la fonction f(x) = log2(1 + x) . . . . . . 39

2.7 Découpage du mot Sk en Sk,1, Sk,2, . . . , Sk,mk. . . . . . . . . . . . . . . . . . . . . . . 42

2.8 Correspondance entre les Sk,j et les S∗k,j . . . . . . . . . . . . . . . . . . . . . . . . . . 43

2.9 Exemple de décomposition par symétrie pour le calcul du produitQk(A,B∗) . . . . 442.10 Reconstruction du produit Qk(A,B∗) à partir de ses sous-produitsQk,j(A,Sk,j) . . . 452.11 Approximation de la somme des produits partiels avec les paramètres λk et µk . . . 482.12 Approximation de la somme des produits partiels avec les paramètres λk et µk,

corrigée par l’ajout d’une constante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

viii Liste des figures

2.13 Découpage du mot d’entréeX en Ak et Bk . . . . . . . . . . . . . . . . . . . . . . . . 502.14 Découpage du mot d’entréeX en plusieurs Ak,j et Bk . . . . . . . . . . . . . . . . . . 512.15 Représentation des termes T ′

0, T′1 et T

′2 pour la fonction f(x) = log2(1 + x) . . . . . . 53

2.16 Architecture globale d’un opérateur HOTBM . . . . . . . . . . . . . . . . . . . . . . . 542.17 Architecture des termes T ∗

0 (A0) et T ∗k (Ak, B

∗k) implémentés par de simples tables . . 54

2.18 Architecture du terme T ∗k (Ak, B

∗k) implementé sous forme puissance et produit . . . 55

2.19 Architecture d’un opérateur d’élévation à la puissance k par somme des produitspartiels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

2.20 Représentation de l’erreur d’approximation ǫpoly(X) de la fonction f(x) = log2(1 + x) 582.21 Représentation de l’erreur ǫmethod,A2(X) commise sur le terme T ′

2 avec α2 = 1 bit . . 592.22 Erreurs commises sur des termes d’ordre 1, 2 et 3 pour différentes valeurs de βk < β 622.23 Amélioration de l’encadrement des erreurs de la figure 2.22 . . . . . . . . . . . . . . 632.24 Erreur ǫmethod,B2(X) commise sur le terme T ′

2 pour l’exemple f(x) = log2(1 + x) . . 642.25 Erreurs commises sur les termes tabulés T ′

1, T′2 et T

′3 . . . . . . . . . . . . . . . . . . . 65

2.26 Erreur ǫmethod,A2,B2(X) commise sur le terme T ′2 pour l’exemple f(x) = log2(1 + x) . 66

2.27 Erreur ǫmethod,S2(X) commise sur le terme T ′2 pour l’exemple f(x) = log2(1 + x) . . . 67

2.28 Erreur ǫmethod,A1,2(X) commise sur le sous-produit Q1,2 pour l’exemple f(x) =log2(1 + x) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68

2.29 Erreur deméthode totale ǫmethod(X) commise par l’opérateur HOTBM sur l’exemp-le f(x) = log2(1 + x) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

2.30 Erreur de méthode ǫmethod(X) pour la fonction f(x) = log2(1 + x) recentrée autourde zéro grâce au terme correctif C(A) . . . . . . . . . . . . . . . . . . . . . . . . . . . 70

2.31 Erreurs d’arrondis ǫround(X) commises pour g = 4 bits de garde sur l’exemplef(x) = log2(1 + x) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

2.32 Estimations de surfaces et délais pour les fonctions sin(

π4 x)et log2(1 + x) . . . . . . 74

3.1 Représentation en virgule flottante d’un nombreX . . . . . . . . . . . . . . . . . . . 793.2 Représentation en système logarithmique d’un nombre X . . . . . . . . . . . . . . . 793.3 Architecture de l’additionneur en virgule flottante . . . . . . . . . . . . . . . . . . . . 813.4 Architecture du diviseur en virgule flottante . . . . . . . . . . . . . . . . . . . . . . . 823.5 Architecture générale de l’additionneur en système logarithmique . . . . . . . . . . . 833.6 Architecture de l’évaluation de f⊕ et f⊖ par la méthode d’ordre 2 . . . . . . . . . . . 843.7 Caractéristiques des additionneurs en virgule flottante et en LNS-O1 . . . . . . . . . 863.8 Caractéristiques des opérateurs en virgule flottante et en LNS . . . . . . . . . . . . . 873.9 Caractéristiques des versions combinatoire et pipelinée du diviseur en virgule flot-

tante. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 873.10 Architecture de l’opérateur de calcul de la norme R =

√X2 + Y 2 . . . . . . . . . . . 88

3.11 Caractéristiques de l’opérateur de calcul de R =√

A2 + B2 . . . . . . . . . . . . . . . 903.12 Architecture de l’opérateur de produit scalaire en dimension 3. . . . . . . . . . . . . 903.13 Caractéristiques de l’opérateur de produit scalaire en dimension 3 . . . . . . . . . . . 903.14 Architecture de l’opérateur de transformation 3D . . . . . . . . . . . . . . . . . . . . 913.15 Image calculée en système logarithmique avec une faible précision (wI , wF ) = (5, 8) 923.16 Images calculées pour les deux systèmes de représentation et avec diverses précisions 93

4.1 Architecture du logarithme en virgule flottante . . . . . . . . . . . . . . . . . . . . . . 984.2 Caractéristiques de l’opérateur pour le logarithme en virgule flottante . . . . . . . . 1004.3 Caractéristiques comparées de l’opérateur selon l’utilisation ou non des petits mul-

tiplieurs 18 × 18 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1014.4 Caractéristiques comparées de l’opérateur entre versions combinatoire et pipelinée . 101

Liste des figures ix

4.5 Architecture de l’exponentielle en virgule flottante . . . . . . . . . . . . . . . . . . . . 1054.6 Caractéristiques de l’opérateur pour l’exponentielle en virgule flottante . . . . . . . 1084.7 Caractéristiques comparées de l’opérateur selon l’utilisation ou non des petits mul-

tiplieurs 18 × 18 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1094.8 Caractéristiques comparées de l’opérateur entre versions combinatoire et pipelinée . 1094.9 Réduction d’argument trigonométrique par quadrants . . . . . . . . . . . . . . . . . 1104.10 Architecture générale de l’opérateur dual sinus/cosinus en virgule flottante . . . . . 1134.11 Architecture détaillée de la réduction d’argument dual path . . . . . . . . . . . . . . 1144.12 Architectures détaillées de l’évaluation du sinus et du cosinus . . . . . . . . . . . . . 115

Liste des tables

2.1 Coefficients de l’approximation par morceaux de la fonction f(x) = log2(1 + x) . . . 352.2 Coefficients de l’approximation par morceaux de la fonction f(x) = log2(1 + x)

après extraction de la symétrie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382.3 Coefficients des termes et sous-produits après réduction de la précision des Ak,j et

Bk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 522.4 Borne de l’erreur absolue ǫabs

poly,PAengendrée par l’approximation de f(x) = log2(1+

x) par un polynôme minimax sur l’intervalle IA . . . . . . . . . . . . . . . . . . . . . 572.5 Erreur sur les coefficients d’ordre 2 de la fonction f(x) = log2(1 + x) pour α2 = 1 bit 592.6 Erreur sur les coefficients du sous-produit Q1,2 pour la fonction f(x) = log2(1 + x),

avec α1,2 = 2 bits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 682.7 Extrema et correctifC(A) de l’erreur deméthode ǫmethod(X) pour la fonction f(x) =

log2(1 + x) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 702.8 Exemples de décompositions possibles pour l’approximation de la fonction sin

(π4 x)75

3.1 Valeur d’un nombre X en virgule flottante en fonction de son drapeau d’exceptionexnX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

3.2 Valeur d’un nombreX en système logarithmique en fonction de son drapeau d’exceptionexnX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

3.3 Exemples de comparaisons entre diverses combinaisons de dynamique, précisionet système de représentation des nombres . . . . . . . . . . . . . . . . . . . . . . . . . 86

4.1 Surface et délai de l’opérateur pour le logarithme . . . . . . . . . . . . . . . . . . . . 1014.2 Performances comparées de l’opérateur avec un processeur Intel Xeon, en simple

précision . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1024.3 Surface et délai de l’opérateur pour l’exponentielle . . . . . . . . . . . . . . . . . . . . 1084.4 Performances comparées de l’opérateur avec un processeur Intel Xeon, en simple

précision . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1094.5 Surface et délai des différentes variantes d’opérateurs trigonométriques . . . . . . . 117

Introduction

Depuis les années 60, la Loi deMoore, qui prédit que la complexité en termes de transistors descircuits intégrés double tous les deux ans, reste vérifiée. Les circuits reconfigurables de type FPGA(pour Field-Programmable Gate Array) n’ont pas échappé à cette loi. Depuis les premiers FPGA,développés comme une évolution naturelle des CPLD (Complex Programmable Logic Devices),ces circuits n’ont cessé de gagner en complexité et intègrent désormais jusqu’à un milliard detransistors pour les générations les plus récentes. Cette augmentation du niveau d’intégrations’est traduite par une croissance similaire de la puissance de calcul de ces circuits. Les FPGA, audébut restreints au simple rôle de glue logic, ont été ensuite utilisés pour faire du prototypagerapide d’ASIC (Application-Specific Integrated Circuits) et trouvent depuis quelques années leurplace dans de nombreux domaines d’applications.Même s’ils restent moins performants que de véritables circuits intégrés ASIC, leur faible coût

unitaire, leur flexibilité et surtout le parallélisme à grain fin lié à leur structure en font des ciblesidéales pour des applications de calcul intensif. Ces applications, qui présentent généralement unfort parallélisme de données, sont souvent trop spécifiques pour être efficaces sur des processeursgénéralistes. Ces dernières années ont ainsi vu l’apparition de ces circuits reconfigurables en tantque coprocesseurs dans des super-calculateurs, pouvant être reconfigurés spécifiquement pourcorrespondre aux besoins en calculs de chaque application.Du point de vue arithmétique, l’évolution du niveau d’intégration des FPGA s’est accompa-

gnée de l’apparition progressive d’opérateurs rapides intégrés à ces circuits. Ainsi, si les premiersFPGA ne comportaient que des cellules logiques, les générations suivantes pouvaient déjà fairedes additions rapides, grâce à de la logique et du routage ad-hoc. Désormais, la plupart des FPGAintègre aussi de petits multiplieurs et même des opérateurs de multiplication-accumulation. Ce-pendant, les composants arithmétiques embarqués dans ces circuits sont dédiés au calcul entier etne peuvent pas suffire aux besoins des applications travaillant sur des nombres réels. Il y a doncde ce point de vue là une nécessité pour ces applications d’avoir à disposition des opérateurs pourcalculer sur ces nombres réels.La motivation commune à tous les travaux présentés ici fut ainsi de développer des biblio-

thèques d’opérateurs destinés à l’arithmétique des nombres réels sur FPGA. Au delà du besoinpour de telles bibliothèques, d’autres questions subsistent :– Quel système de représentation des nombres ?La virgule fixe, format très proche des entiers, offre des opérateurs petits et rapides. Elle n’estnéanmoins pas capable de supporter des nombres ayant une dynamique trop importante,ce qui restreint son utilisation essentiellement aux applications de traitement du signal.La virgule flottante, au contraire, permet de manipuler une gamme de valeurs et d’ordresde grandeur bien plus large, mais en contrepartie les opérateurs pour ce système sont rela-tivement plus complexes que leurs équivalents en virgule fixe. Cependant, l’intérêt d’un telsystème est que la plupart des algorithmes numériques en logiciel utilisent ce format, et leurportage sur circuit ne requiert aucune connaissance particulière en arithmétique.Enfin, d’autres systèmes de représentation existent aussi, comme les systèmes logarithmique

2 Introduction

et semi-logarithmique, tous deux des alternatives à la virgule flottante.– Quelle précision ?Quel que soit le système de représentation adopté, le choix de la précision des valeurs ma-nipulées joue un rôle prépondérant sur le coût et les performances du circuit. Ainsi, intui-tivement, plus la précision requise sera grande et plus les opérateurs seront gros et lents. Àl’inverse, un circuit conçu pour être petit et rapide sera enclin à faire des calculs entachésd’importantes erreurs.– Quelle cible ? Quelles contraintes ?Selon les propriétés architecturales du FPGA ciblé, comme par exemple s’il possède ou nondes petits multiplieurs entiers câblés, ou bien simplement le nombre de cellules logiquesdont il dispose, l’opérateur optimal pour réaliser un calcul donné peut changer radicale-ment. De même, des contraintes architecturales ou temporelles supplémentaires sur le cir-cuit peuvent aussi influencer le choix de l’opérateur adapté.Les réponses à chacune de ces questions dépendent bien évidemment de l’application concer-

née, et il faut donc proposer des opérateurs les plus flexibles possible pour leur permettre des’adapter le mieux possible aux besoins spécifiques de chaque application. Il nous semble doncessentiel de fournir des opérateurs pour divers formats de représentation des nombres, paramé-trables en termes de précision et enfin capables de s’adapter aux contraintes et besoins spécifiquesde chaque application.Une autre objectif important est de fournir des garanties fortes sur la qualité des calculs ef-

fectués par les opérateurs. Ces garanties reposent sur des analyses d’erreurs rigoureuses de tousles opérateurs, permettant de s’assurer que les erreurs commises dans ces opérateurs sont toutesmaîtrisées et ne risquent pas de dégrader la précision attendue des résultats.Les travaux présentés dans cette thèse tentent d’apporter des réponses et des solutions à ces

objectifs dans le cas de l’évaluation de fonctions élémentaires en virgule fixe, des opérateurs debase en virgule flottante et dans le système logarithmique et enfin de l’évaluation de fonctionsélémentaires en virgule flottante.Ainsi, après un premier chapitre introductif présentant les notations, les systèmes de représen-

tation des réels et les circuits reconfigurables FPGA, nous exposons dans le chapitre 2 une nouvelleméthode générale pour l’évaluation en virgule fixe de fonctions élémentaires, ainsi que son im-plémentation sous forme d’un générateur d’opérateurs. Cette méthode est une généralisation etune extension de plusieurs autres méthodes à base de tables. Elle est novatrice en ce sens qu’elleautorise une liberté architecturale presque totale grâce à des dizaines de paramètres intervenantlors de la conception de l’opérateur. La conception de cet opérateur est aussi contrôlée par uneanalyse d’erreur très fine permettant de garantir la précision du calcul.Le chapitre 3 présente ensuite FPLibrary, une bibliothèque d’opérateurs de base pour le calcul

réel sur FPGA, supportant à la fois la virgule flottante et le système logarithmique pour diversesprécisions. La présence d’opérateurs pour ces deux systèmes de représentation des réels permetde comparer de manière transparente l’implémentation d’une application donnée dans les deuxarithmétiques pour pouvoir choisir le système le plus adapté à cette application. L’utilisation desparamètres de précision offre alors la possibilité d’explorer pour chaque application le compromisentre système de représentation, précision, coût et performance.Le chapitre 4 détaille pour sa part des opérateurs pour le calcul de fonctions élémentaires

(logarithme, exponentielle et fonctions trigonométriques sinus et cosinus) en virgule flottante,intégrés à FPLibrary. Encore une fois, ces opérateurs, complètement paramétrés en termes de pré-cision permettent d’étudier différents compromis pour chaque application. Contrairement auxopérateurs de base de FPLibrary, dont les algorithmes d’évaluation étaient déjà bien connus, lestechniques développées pour les fonctions élémentaires sont généralement nouvelles, car les algo-rithmes existants sont pour la plupart orientés vers une implémentation logicielle. Enfin, là encore,

Introduction 3

la précision des opérateurs est garantie grâce à des analyses d’erreurs ad-hoc.Enfin, un rappel des diverses contributions des travaux présentés dans cette thèse ainsi que

les réflexions et perspectives soulevées par les résultats obtenus viennent conclure ce document.

1 CHAPITRE 1

Contexte

Ce chapitre présente le contexte dans lequel se placent les travaux décrits dans ce document.Ainsi, la partie 1.1 introduit tout d’abord pour plus de clarté les notations utilisées par la suite.La partie 1.2 explicite ensuite la notion d’arithmétique réelle telle qu’entendue dans le docu-

ment. Elle détaille tour à tour les trois systèmes de représentation des nombres réels étudiés :virgule fixe, virgule flottante et système logarithmique. Pour chacune de ces arithmétiques sontprésentés leur format de représentation des nombres, leur dynamique, leur précision, ainsi qu’unbref descriptif des algorithmes des opérations de base sur ces nombres (addition, soustraction,multiplication, division et racine carrée).Enfin, la partie 1.3, quant à elle, présente rapidement les caractéristiques des FPGA, qui sont

la technologie ciblée par les opérateurs arithmétiques présentés par la suite. Elle détaille ainsi l’ar-chitecture générale de ces circuits reconfigurables ainsi que le modèle de programmation utilisé,avant de conclure par une courte discussion sur des notions de portabilité entre différents modèlesde FPGA.

1.1 Notations

Tout au long de ce document, nous allons manipuler et travailler autour de nombres entiers etréels, tantôt d’un point de vue purement mathématique, tantôt d’un point de vue de leur repré-sentation matérielle sous forme de vecteurs de bits. Pour différencier ces deux cas et éviter toutrisque de confusion, nous dénoterons donc les valeurs mathématiques par des lettres minuscules(x, y, z, . . .), alors que les représentations matérielles de ces nombres seront identifiées par deslettres majuscules (X, Y , Z , . . .).D’une manière générale, la taille d’un vecteur de bits X sera notée wX .De plus, considérant un vecteur de bits X, la notation X(i) nous permettra de désigner le bit

de rang i de ce vecteurX. Ainsi, on peut exprimerX comme la concaténation de seswX bits grâceà la notation suivante :

X = X(wX−1)X(wX−2) · · ·X(1)X(0).

X désignera ainsi le vecteur de bits de même que la valeur représentée par ce vecteur. Saufmention contraire, les vecteurs de bits manipulés encoderont le plus souvent des valeurs entièrespositives, ainsi représentées en binaire classique :

X =

wX−1∑

i=0

X(i)2i.

6 Chapitre 1. Contexte

Les valeurs négatives, explicitement désignées comme telles, seront quant à elles encodées encomplément à deux :

X =

wX−2∑

i=0

X(i)2i − X(wX−1)2

wX−1.

Enfin, l’erreur commise entre un nombre x et sa représentationX sera notée ǫX :

ǫX = x − X.

De manière similaire, les erreurs absolue et relative seront notées respectivement ǫabsX et ǫrel

X :

ǫabsX = |x − X|, et

ǫrelX =

∣∣∣∣x − X

x

∣∣∣∣ .

Dans la suite de ce document, ces erreurs ne seront pas uniquement des erreurs de représen-tation, c’est-à-dire la distance entre le nombre réel x et sa valeur la plus proche dans le système dereprésentation courant. X pourra en effet être entaché d’autres erreurs, accumulées tout au longdu calcul. Dans le doute, on précisera explicitement le sens de chacune de ces notations.

1.2 Arithmétique(s) réelle(s)

Le terme d’arithmétique réelle tel qu’utilisé dans le cadre de ce document ne désigne pas unearithmétique exacte sur les nombres réels, mais englobe plutôt un certain nombre d’arithmétiquespermettant de manipuler et de calculer sur des représentations approchées de ces nombres réels.Ainsi, chacune de ces arithmétiques est fortement liée à un système de représentation des

nombres. Parmi les systèmes les plus connus, on peut compter :– la représentation en virgule fixe, présentée section 1.2.1,– la représentation en virgule flottante, section 1.2.2, et– le système logarithmique, section 1.2.3.Bien d’autres systèmes existent, tels que le système semi-logarithmique [MST98], hybride entre

la virgule flottante et le système logarithmique, ou encore le système SLI (Symmetric Level-Index),mis au point par Clenshaw et Olver [CO84].Cependant, pour des raisons évidentes de temps ainsi que pour répondre aux besoins immé-

diats de la communauté, nous ne nous sommes concentrés que sur les trois premiers systèmes dereprésentation des nombres réels, décrits plus en détails dans les sections suivantes.

1.2.1 Virgule fixe

Représentation

La virgule fixe, parfois appelée FXP pour FiXed-Point, est certainement le système de repré-sentation des nombres réels le plus simple, pour ne pas dire le plus naturel. Un nombre en virgulefixe X est représenté par sa partie entière notée IX et sa partie fractionnaire FX , respectivementsur wI et wF bits, comme schématisé figure 1.1.La taille de la partie fractionnaire étant fixée àwF bits, la représentation en virgule fixe est donc

plus simplement une représentation entière mise à l’échelle par une puissance (le plus souventnégative) de 2 :

X = IX + FX × 2−wF = IXFX × 2−wF .

1.2 Arithmétique(s) réelle(s) 7

, FXIX

wI wF

Figure 1.1 Représentation en virgule fixe d’un nombreX.

On peut ainsi noter la position de la virgule binaire dans l’écriture du nombreX de la manièresuivante :

X = IX ,FX .

Enfin, on indexera par leur poids les bits d’un nombre en virgule fixeX :

X = X(wI−1) · · ·X(1)X(0),X(−1) · · ·X(−wF )

=

wI−1∑

i=−wF

X(i)2i.

Exemple 1.1 Pour wI = 3 bits de partie entière et wF = 5 bits de partie fractionnaire, onconsidère la représentation en virgule fixe suivante :

X = 101 01101 .

Sa valeur est donc :X = 101,01101 = 10101101 × 2−5

= 173 × 2−5 = 5,40625.

Dynamique

Pour une représentation en virgule fixe découpée selon (wI , wF ), la dynamique des nombresX représentables dans ce système est donnée par l’encadrement suivant :

0 ≤ X ≤ 2wI − 2−wF .

Ainsi, le nombre de bits nécessaires est directement lié à la dynamique des nombres à repré-senter. Il devient rapidement très coûteux de représenter en virgule fixe des valeurs d’ordres degrandeur différents.

Précision

Comme il ne s’agit en fait que d’entiers mis à une certaine échelle, les nombres représentablesen virgule fixe sont régulièrement espacés, comme représenté figure 1.2.

2−wF

2wI10

Figure 1.2 Axe des nombres représentables en virgule fixe, pour (wI , wF ) = (2, 3).

Ainsi, en notant ǫabsFXP(x) l’erreur absolue de représentation commise entre un nombre réel

x ∈ [0, 2−wI [ et sa représentation en virgule fixe X arrondie vers le bas :

ǫabsFXP(x) = |x − X|,


cette erreur peut être bornée par la distance entre deux nombres représentables consécutifs, com-me en témoigne la figure 1.3 :

ǫabsFXP(x) < 2−wF , pour tout x ∈ [0, 2−wI [.

0

0,05

0,1

2−wF

0 1 2 3 4

x

ǫabsFXP(x)

Figure 1.3 Comportement de l’erreur absolue de représentation en virgule fixe ǫabsFXP(x), pour

(wI , wF ) = (2, 3).

Cette valeur maximale de 2−wF correspond au poids du bit le plus faible du système de repré-sentation. Elle est couramment appelée ulp, pour unit in the last place. Comme nous pourrons levoir par la suite, cette notation est très utile pour effectuer l’analyse d’erreur d’un algorithme oud’un opérateur.Si l’on note ǫrel

FXP(x) l’erreur relative de représentation commise en virgule fixe :

ǫrelFXP(x) =

∣∣∣∣x − X

x

∣∣∣∣ ,

on peut se rendre compte que celle-ci est beaucoup plus grande pour des valeurs proches de zéro,comme le montre la figure 1.4. L’erreur relative est potentiellement très importante :

ǫrelFXP(x) ≤ 1, pour tout x ∈ [0, 2−wI [.

Le raisonnement précédent, appliqué ici au cas de l’arrondi vers le bas, peut aussi être généra-lisé à l’arrondi vers le haut ou au plus proche. Ainsi, l’erreur absolue de représentation est doncaussi bornée par 1 ulp pour l’arrondi vers le haut, et par 1

2 ulp pour l’arrondi au plus proche.

Opérations de base

Du fait de la grande proximité entre représentation en virgule fixe et représentation entière,les opérations de bases (addition, soustraction, multiplication, division et racine carrée) en virgulefixe se ramènent aisément à leur équivalent entier.Ainsi, l’addition de deux nombres en virgule fixe X et Y revient simplement à calculer la

somme des entiers IXFX et IY FY :

X + Y = IXFX × 2−wF + IY FY × 2−wF

=(IXFX + IY FY

)× 2−wF .


0

0,25

0,5

0,75

1

0 1 2 3 4

x

ǫrelFXP(x)

Figure 1.4 Comportement de l’erreur relative de représentation en virgule fixe ǫrelFXP(x), pour

(wI , wF ) = (2, 3).

Dans le cas où le découpage (wI , wF ) n’est pas le même pourX et Y , un décalage constant (etpar conséquent gratuit en matériel) suffit pour aligner les virgules.Le même genre de raisonnement s’applique pour les autres opérations. Pour plus de détails,

voir [Mul89], [Par99], [FO01] ou [EL03].

Conclusion

En résumé, la représentation en virgule fixe est très intéressante du fait de sa simplicité et desopérateurs pour ce système peuvent être rapidement dérivés à partir de leur équivalent entier. Parcontre, la faible dynamique des nombres représentables ainsi qu’une erreur relative de représen-tation trop mal maîtrisée en restreignent grandement l’usage.Nous verrons néanmoins que les algorithmes pour les système à virgule flottante ou logarith-

mique reposent sur des représentations internes et des calculs en virgule fixe.

1.2.2 Virgule flottante

Représentation

Le système de représentation en virgule flottante, aussi noté FP pour Floating-Point, est direc-tement inspiré du système de notation dit scientifique : un nombre est représenté par une valeuren virgule fixe, appelée mantisse (ou significande), ainsi qu’un ordre de grandeur sous la formed’un facteur exponentiel. Cela nous donne ainsi la représentation suivante pour un nombre X :

X = MX × βEX ,

avec :– MX la mantisse deX,– EX l’exposant entier deX, et– β la base de la représentation (typiquement 2 ou 10).Le plus souvent, la mantisseMX est normalisée pour assurer l’unicité de la représentation de

chaque nombre :1 ≤ MX < β.


Dans la suite, nous nous placerons dans le cadre de la virgule flottante en base β = 2. Enconsidérant que la mantisse est toujours normalisée, on a 1 ≤ MX < 2. Ainsi, sa partie entièrevaut toujours 1, et on peut donc l’écrire sous la forme :

MX = 1,FX ,

avec FX la partie fractionnaire de cette mantisse normalisée, aussi appelée fraction. Le 1 de lapartie entière n’a dès lors plus besoin d’être stocké dans la représentation : on parle alors de 1implicite.Pour pouvoir représenter les nombres positifs comme négatifs, on adjoint à la représentation

un bit de signe SX , ce qui donne ainsi :

X = (−1)SX × 1,FX × 2EX .

Enfin, on notera wF la taille en bits de la fraction, et wE celle de l’exposant. Un nombreX seraainsi représenté en matériel comme la concaténation de son bit de signe SX , de son exposant EX

et de sa fraction FX , comme indiqué figure 1.5. Cela correspond donc à un vecteur de wE +wF +1bits.

SX

1

EX

wE wF

FX

Figure 1.5 Représentation en virgule flottante d’un nombreX.

La norme IEEE 754

La norme IEEE Standard for Binary Floating-Point Arithmetic (ANSI/IEEE Std 754-1985 ouencore IEC 60559 :1989) [AI85], aussi plus simplement appelée IEEE 754, a été élaborée pour dé-finir une spécification unique de la représentation en virgule flottante en base 2. L’objectif étaitd’améliorer la compatibilité entre les diverses architectures, et par là même la portabilité des ap-plications, ainsi que la qualité des calculs dans cette arithmétique. Ainsi, de nos jours, la plupartdes systèmes respectent cette norme.La norme IEEE 754 définit de nombreuses notions, parmi lesquelles :

Exposant biaisé Plutôt que de représenter l’exposant EX comme un nombre entier signé en com-plément à deux, la norme impose de représenterEX comme l’exposant deX biaisé par E0 :

E0 = 2wE−1 − 1.

Cela donne alors :X = (−1)SX × 1,FX × 2EX−E0 .

Cette représentation de l’exposant permet de simplifier les comparaisons entre nombres flot-tants de même signe, qui peuvent ainsi se ramener à des comparaisons entières sur leur re-présentationEXFX , l’ordre des champs exposant et fraction correspondant justement l’ordrelexicographique de la comparaison flottante.

Nombres dénormalisés La mantisse normalisée et le 1 implicite nous empêchant de pouvoir re-présenter le nombre 0, la norme définit une représentation alternative lorsque l’exposantEX

vaut 0 :X = (−1)SX × 0,FX × 21−E0 .


Cela permet ainsi de représenter correctement 0 avec FX = 0 et EX = 0, mais aussi d’avoirune représentation des nombres compris entre 0 et le plus petit nombre flottant normaliséreprésentable.Il est d’ailleurs important de noter que, dans ce système, 0 a deux représentations distinctes,selon la valeur de SX : le 0 en virgule flottante est signé.

Infinis Demême que le plus petit exposantEX = 0 sert à représenter les nombres très proches de0, sa valeur maximale EX = 2wE −1 permet de représenter les valeurs+∞ et−∞. La normeimpose de plus que, dans ces cas-là, la valeur de la fraction FX soit nulle. Ainsi :

X = (−1)SX ×∞ =

{+∞ lorsque SX = 0, et−∞ sinon.

Not a Number La norme supporte aussi la représentationde résultats de calculs incorrects, comme√−1 ou∞ − ∞. Un tel résultat est appelé NaN, pour Not a Number, et est représenté parl’exposant maximal EX = 2wE − 1 et une fraction FX non nulle.

Arrondi au plus proche pair Lors de l’arrondi au plus proche d’un nombre réel x, si celui-ci setrouve à équidistance entre deux nombres représentables, il est alors arrondi vers celui desdeux nombres dont le plus petit bit significatif de la fraction FX,(−wF ) est nul.

La norme IEEE 754 définit de plus deux formats de virgule flottante :– la simple précision, sur 32 bits, avec (wE , wF ) = (8, 23), et– la double précision, sur 64 bits, avec (wE , wF ) = (11, 52).Il est à noter que dans les opérateurs que nous présentons par la suite, le codage des valeurs

exceptionnelles comme les zéros, les infinis ou bien Not a Number n’est pas géré de la mêmemanière : nous préférons utiliser deux bits supplémentaires pour représenter ces valeurs, commedétaillé dans le chapitre 3.

Exemple 1.2 Pour wE = 3 bits d’exposant et wF = 5 bits de fraction, on considère la repré-sentation en virgule flottante suivante :

X = 1 101 01101 .

On a donc :SX = 1,

EX = 101 = 5, et

FX = 0,01101 = 13 × 2−5 = 0,40625.

Comme EX 6= 0 et EX 6= 7, il s’agit d’une représentation normalisée :

X = (−1)1 × 1,40625 × 25−E0 = −1,40625 × 25−3 = −5,625.

Exemple 1.3 Pour les mêmes valeurs de wE et wF , on considère la représentation suivante :

Y = 0 000 01101 .

On a ainsi :SY = 0,

EY = 000 = 0, et


FY = 0,01101 = 13 × 2−5 = 0,40625.

Comme EY = 0, il s’agit là d’une représentation dénormalisée :

Y = (−1)0 × 0,40625 × 21−3 = 0,1015625.

Dynamique

La représentation sous forme d’une mantisse et d’un ordre de grandeur permet de représenterun intervalle de valeurs bien plus important que ce que n’autorise le système en virgule fixe. Ainsi,pour ce qui est des nombres normalisés, on a l’encadrement de l’exposant suivant :

1 ≤ EX ≤ 2wE − 2 = 2E0,

ce qui donne :1 − E0 ≤ EX − E0 ≤ E0.

Comme on a de plus pour la mantisse :

1 ≤ 1,FX ≤ 2 − 2−wF ,

on obtient ainsi l’encadrement en valeur absolue des nombres représentables sous forme norma-lisée :

21−E0 ≤ |X| ≤(2 − 2−wF

)× 2E0 .

On note alors l’intervalle des nombres positifs normalisés :

N =[21−E0 , 21+E0

[.

Quant aux nombres dénormalisés, ils comblent l’intervalle entre 0 et le plus petit nombre flot-tant normalisé :

0 ≤ |X| ≤(1 − 2−wF

)× 21−E0 .

On note cet intervalle comme suit :D =

[0, 21−E0

[.

Enfin, les zéros et infinis permettent de détecter et maîtriser les éventuels dépassements decapacité, ce qui constitue aussi un avantage conséquent sur la virgule fixe.

Précision

Dans l’ensemble de cette section, nous ne considérons que les nombres flottants positifs. Lemême raisonnement s’applique de manière identique aux valeurs négatives, du fait de la repré-sentation sous forme signe et valeur absolue du système flottant.En observant l’ensemble des nombresX représentables sous forme normalisée en virgule flot-

tante, on peut remarquer que celui-ci se partitionne naturellement en binades BEX, suivant la

valeur de l’exposant EX , avec :

Bk =[2k−E0, 2k−E0+1

[.

Comme il s’agit d’une partition, on a :

N =

2E0⋃

k=1

Bk.


Ainsi, tous les nombres flottants d’une binade Bk partagent le même exposant EX = k. Danschaque binade, les nombres représentables sont répartis régulièrement, à la manière de la virgulefixe, selon la valeur de leur fraction FX . Cependant, d’une binade à l’autre, la distance entre deuxnombres représentables consécutifs n’est pas la même, du fait de la différence entre les exposants.Les nombres dénormalisés sont quant à eux régulièrement répartis sur l’intervalle D.La figure 1.6 donne l’ensemble des nombres représentables sur l’intervalle [0, 2] pour wE = 3

bits d’exposant et wF = 3 bits de fraction. On peut ainsi y voir les trois premières binades B1, B2 etB3, correspondant aux exposants EX = 1, 2 et 3 (les binades suivantes ne sont pas représentées),ainsi que les nombres dénormalisés D.

2−wF−2 2−wF−1 2−wF

0 1 2

B3B2D B1

Figure 1.6 Axe des nombres positifs représentables en virgule flottante sur l’intervalle [0, 2], pour(wE , wF ) = (3, 3).

Demême que pour la virgule fixe, l’erreur absolue commise sur une représentationflottante estmesurée grâce à la quantité ulp. Elle désigne ici aussi la distance séparant deux nombres flottantsconsécutifs. Cependant, dans le cas de la virgule flottante, la valeur de l’ulp change d’une binadeà l’autre.Plusieurs définitions de l’ulp existent [Mul05b]. Nous choisissons pour notre part de définir

ulp comme une fonction du nombre réel x à approcher, avec ulp(x) représentant la distance entreles deux nombres flottants les plus proches encadrant x [Har99].En prenant x dans la binade Bk, on a donc :

ulp(x) = 2k−E0−wF ,

et avec x dans l’intervalle des nombres dénormalisés D, on obtient :

ulp(x) = 21−E0−wF .

Ainsi, l’erreur absolue de représentation ǫabsFP (x) commise entre un nombre réel x et sa repré-

sentation flottante approchée X est toujours bornée. Dans le cas de l’arrondi vers le bas, celadonne :

ǫabsFP (x) < 1 ulp(x), pour tout x ∈ D ∪N .

De manière intuitive, l’erreur de représentation est importante lorsque x est grand en valeurabsolue, mais diminue de binade en binade au fur et à mesure que x se rapproche de 0. On peutdonc observer ce phénomène sur la figure 1.7, représentant l’erreur absolue de représentation envirgule flottante ǫabs

FP (x) entre un nombre réel x ∈ [0, 2] et sa représentationX arrondie vers le bas.Ainsi, comme l’ordre de grandeur de l’erreur absolue augmente avec l’ordre de grandeur de

x, l’erreur relative ǫrelFP(x) commise pour les représentations normalisées est bien bornée :

ǫrelFP(x) < 2−wF , pour tout x ∈ N .

Par contre, en ce qui concerne les nombres dénormalisés, comme il ne s’agit en réalité qued’une représentation en virgule fixe, l’erreur relative maximale est beaucoup plus importante.Toutefois, cela ne concerne qu’une infime partie des nombres représentables. Nous ne tiendronsdonc pas compte dans la suite du document de ce cas limite, et considérerons ainsi que l’erreurrelative de représentation en virgule flottante ǫrel

FP(x) est bien bornée par 2−wF .


0

2−wF −2

2−wF −1

2−wF

0 0,25 0,5 1 2

x

ǫabsFP (x) D B1 B2 B3

Figure 1.7 Comportement de l’erreur absolue de représentation en virgule flottante ǫabsFP (x) sur

l’intervalle [0, 2], pour (wE , wF ) = (3, 3).

La figure 1.8 représente le comportement de cette erreur relative ǫrelFP(x) pour wE = 3 bits d’ex-

posant, wF = 3 bits de fraction et x dans l’intervalle [0, 2]. On peut ainsi y constater que la courbeenveloppe de l’erreur oscille entre 2−wF−1 et 2−wF pour les nombres représentables sous formenormalisée (ici, x ≥ 0,25), mais dépasse cette borne sur l’intervalle des nombres dénormalisés(0 ≤ x < 0,25).

0

2−wF −1

2−wF

0 0,25 0,5 1 2

x

ǫrelFP(x) D B1 B2 B3

Figure 1.8 Comportement de l’erreur relative de représentation en virgule flottante ǫrelFP(x) sur

l’intervalle [0, 2], pour (wE , wF ) = (3, 3).

Le raisonnement précédent, présenté ici uniquement dans le cas de l’arrondi vers le bas, s’ap-plique aussi de la même manière aux autres modes d’arrondi de la virgule flottante, y comprisl’arrondi au plus proche. Pour ce dernier cas, l’erreur absolue de représentation d’un réel x estbornée par 1/2 ulp(x).


Opérations de base

Les cinq opérations de base en virgule flottante se ramènent assez simplement à leur équi-valent en virgule fixe appliqué aux mantisses des opérandes.Ainsi, multiplication et division en virgule flottante reviennent à calculer en virgule fixe res-

pectivement le produit et le quotient des mantisses, ainsi que la somme et la différence des expo-sants des deux opérandes. Il en va de même pour la racine carrée, qui revient à extraire en virgulefixe la racine carrée de la mantisse et à diviser l’exposant par deux. Pour ces trois opérations, lerésultat final est obtenu après une simple étape de renormalisation et d’arrondi.L’addition et la soustraction demandent quant à elles tout d’abord d’aligner les mantisses des

deux opérandes en fonction de la différence entre leurs exposants. La somme ou la différence entreces mantisses ainsi alignées est alors calculée en virgule fixe. Enfin, le résultat est renormalisépuis arrondi. Cependant, un phénomène d’annulation catastrophique, se produisant lors de lasoustraction de deux nombres très proches, rend cette renormalisation finale plus coûteuse quepour les trois autres opérations, pour lesquelles elle se limite à quelques bits seulement.Tout ceci est détaillé plus avant dans le chapitre 3. Voir là aussi les ouvrages [Mul89], [Par99],

[FO01] ou encore [EL03].

Conclusion

La représentation en virgule flottante permet donc d’atteindre une dynamique inaccessibleavec la seule virgule fixe. De plus, elle offre un bien meilleur contrôle de l’erreur relative de repré-sentation, ce qui la rend nettement plus séduisante pour des applications requérant des garantiesde précision.Enfin, les opérateurs de base pour la virgule flottante sont très proches de leurs équivalents en

virgule fixe et n’entraînent qu’un léger surcoût matériel, à l’exception de l’opérateur d’addition/-soustraction qui est sensiblement plus coûteux.

1.2.3 Système logarithmique

Représentation

Le système logarithmique, aussi appelé LNS (pour Logarithmic Number System), représenteles nombres par leur signe et le logarithme de leur valeur absolue [SA75]. Ce logarithme est quantà lui représenté en virgule fixe. Ainsi, la représentation d’un nombre X est :

X = (−1)SX × βLX ,

avec :– SX le signe deX,– LX le logarithme en base β de |X| en virgule fixe, et– β la base de la représentation LNS.Comme précisé plus haut, LX , le logarithme de X, est représenté en virgule fixe. On note

respectivement IX et FX ses parties entière et fractionnaire. Ainsi :

X = (−1)SX × βIX ,FX .

De plus, pour pouvoir représenter des nombres ayant une faible valeur absolue, le logarithme LX

est signé. On utilise pour cela l’encodage en complément à deux.En fait, le système logarithmique est très proche de la représentation en virgule flottante, IX

jouant le rôle de l’exposant, et β0,FX celui de la mantisse :

X = (−1)SX × β0,FX × βIX .


Ainsi, de même que pour la virgule flottante, nous nous placerons dans la suite de ce documentdans la base β = 2, comme dans l’article original de Swartzlander et Alexopoulos [SA75].Enfin, on note wI et wF les tailles respectives de IX et FX . La représentation matérielle du

nombreX est donc le vecteur de 1+wI +wF bits formé par la concaténation des trois champs SX ,IX et FX , comme représenté figure 1.9.

SX

1

IX

wI wF

FX,

LX

Figure 1.9 Représentation dans le système logarithmique d’un nombre X.

Exemple 1.4 Pour le système de représentation logarithmique avec wI = 3 bits et wF = 5bits, on considère la représentation suivante :

X = 1 010 01101 .

On a donc :SX = 1, et

LX = 010,01101 = 2,40625,

ce qui donne alors :X = (−1)1 × 22,40625 ≈ −5.300947 . . . .

Exemple 1.5 Pour le même système de représentation, on prend :

Y = 0 101 01101 .

Ainsi :SX = 0, et

LX = 101,01101 = −2,59375.

La valeur représentée est donc :

X = (−1)0 × 2−2,59375 ≈ 0,1656546 . . . .

Notions inspirées d’IEEE 754

Pour tenter de rapprocher encore plus le système LNS de la virgule flottante de la norme IEEE754, on pourrait s’inspirer de cette norme pour introduire des notions comme la gestion des zéros,des infinis, deNot a Number ainsi qu’éventuellement des nombres dénormalisés [ABCW92].Nous n’utilisons cependant pas ces extensions-là et choisissons de représenter les valeurs

exceptionnelles grâce à deux bits supplémentaires, de la même manière qu’en virgule flottante,comme présenté dans le chapitre 3.


Arrondi au plus proche

Dans le système logarithmique, l’arrondi dirigé d’un nombre se ramène directement à un ar-rondi dirigé sur son logarithme en base 2. Ce n’est par contre pas le cas pour l’arrondi au plusproche.Prenons deux nombres strictement positifs consécutifsX0 etX1 :

X0 = 2LX0 , et

X1 = 2LX1 = 2LX0+2−wF .

En notant xmid le point situé à équidistance deX0 etX1, on a :

xmid =X0 + X1

2= 2LX0

1 + 22−wF

2,

soit :

log2 (xmid) = LX0 + log2

(1 + 22−wF

2

).

Enfin, en définissant xrnd le point dont le logarithme correspond au milieu des deux loga-rithmes LX0 et LX1 , on trouve :

log2 (xrnd) =LX0 + LX1

2= LX0 + 2−wF−1.

On peut alors prouver que :

log2

(1 + 22−wF

2

)> 2−wF−1,

ce qui donne l’inégalité suivante :xmid > xrnd.

Ainsi, les deux points xmid et xrnd ne coïncident pas, comme illustré figure 1.10. Cela signifiedonc que l’arrondi au plus proche d’un nombre x ∈ ]X0,X1[ est extrêmement difficile à réaliser,puisque la comparaison entre log2(x) et log2(xmid) requiert une précision arbitrairement grande.

X0 xmid X1xrnd

x ≈ X0 x ≈ X1x ≈ X0

ou x ≈ X1

Figure 1.10 Arrondi au plus proche dans le système logarithmique.

L’arrondi au plus proche n’étant ainsi pas envisageable, nous devons nous contenter d’unarrondi fidèle utilisant le point xrnd comme pivot. On arrondit donc x vers X0 quand x ≤ xrnd, etversX1 dans le cas contraire, comme représenté figure 1.11.Cet arrondi est par conséquent biaisé vers le haut, puisque la probabilité d’arrondir vers X1

est que grande que celle d’arrondir vers X0. Toutefois, ce biais a tendance à diminuer avec l’aug-mentation de la précision wF .


X0 xmid X1xrnd

x ≈ X0 x ≈ X1

Figure 1.11 Arrondi fidèle dans le système logarithmique.

Dynamique

La plage des logarithmes LX représentables sous forme normalisée (ni zéros ni infinis) estindiquée par l’encadrement suivant :

1 − 2wI−1 ≤ LX ≤ 2wI−1 − 1 − 2−wF .

Cela nous donne donc la dynamique des nombres dans le système logarithmique :

21−2wI−1 ≤ |X| ≤ 22wI−1−1−2−wF .

On note l’intervalle des nombres positifs de la manière suivante :

N =[21−2wI−1

, 22wI−1−1[.

Ainsi, la virgule flottante avec wE bits d’exposant et le système logarithmique avec wI = wE

bits de partie entière du logarithme ont quasiment la même dynamique (à l’exception près desnombres dénormalisés). Seul un facteur 2 les sépare, car en virgule flottante, on a :

1 − E0 ≤ EX − E0 ≤ 2wE − 1 − E0,

soit :2 − 2wE−1 ≤ EX − E0 ≤ 2wE−1 − 1,

alors que pour le système logarithmique on obtient :

1 − 2wI−1 ≤ IX ≤ 2wI−1 − 2.

Précision

Pour cette section , nous nous plaçons encore une fois dans le cadre des nombres positifs dansle système logarithmique. La symétrie entre nombres positifs et négatifs permet d’étendre le rai-sonnement présenté ici à l’ensemble des nombres représentables.Contrairement à la virgule flottante pour laquelle les nombres sont répartis régulièrement dans

chaque binade, les nombres représentables en système logarithmique sont répartis suivant unesuite géométrique de raison 22−wF . Cette distribution entre 0 et 1 est donnée figure 1.12, avecwI = wF = 3 bits. Elle est bien entendu symétrique pour les nombres négatifs.

0 0,5 10,125 0,25

Figure 1.12Axe des nombres positifs représentables dans le système logarithmique sur l’intervalle[0, 1], pour (wI , wF ) = (3, 3).

La notion d’ulp dans le système logarithmique est plus difficile à définir que pour la virguleflottante, car la distance entre deux nombres consécutifs augmente de manière géométrique. Nous


prenons alors comme ulp du système logarithmique l’ulp de la représentation en virgule fixe dulogarithme LX :

ulp = 2−wF .

Ainsi, l’ulp ne mesure plus une distance mais un rapport entre deux nombres. Si l’erreur entreun nombre x et sa représentationX est de 2 ulp, cela signifie donc que :

X = x · 22·ulp = x · 22·2−wF ,

soit :x − X = x ·

(1 − 22·2−wF

).

Dans le cas de l’arrondi vers le bas d’un nombre positif x, qui correspond donc à l’arrondi versle bas de son logarithme en base 2, on a une erreur au pire de −1 ulp sur le logarithme, ainsi quesur ce nombre. En notant ǫabs

LNS(x) l’erreur absolue entre x et sa représentationX, on a toujours :

ǫabsLNS(x) = |x − X| < x ·

(1 − 2−2−wF

), pour tout x ∈ N .

La figure 1.13 présente ainsi l’erreur absolue de représentation du système logarithmiqueǫabsLNS(x). On y retrouve bien la croissance linéaire de la borne de cette erreur en fonction de x.

0

2−2(1 − 2−2−wF

)

2−1(1 − 2−2−wF

)

20(1 − 2−2−wF

)

0 0,125 0,25 0,5 1

x

ǫabsLNS(x)

Figure 1.13 Comportement de l’erreur absolue de représentation dans le système logarithmiqueǫabsLNS(x) sur l’intervalle [0, 1], pour (wI , wF ) = (3, 3).

L’erreur relative de représentation ǫrelLNS(x), à l’image de l’erreur absolue, est très régulière sur

l’intervalle des nombres représentables positifsN . Ainsi, dans le cas de l’arrondi vers le bas, on a :

ǫrelLNS(x) =

ǫabsLNS(x)

x< 1 − 2−2−wF , pour tout x ∈ N .

Le majorant 1 − 2−2−wF tend vers la valeur 2−wF log 2 lorsque wF augmente. Ainsi, le systèmelogarithmique implique une erreur relative maximale moindre que celle de la virgule flottante. Eneffet, en virgule flottante, la borne sur cette erreur de représentation oscille entre 2−wF−1 et 2−wF .Elle est donc plus importante dans le pire cas que pour le système logarithmique.La figure 1.14 présente ainsi l’erreur relative de représentation sur l’intervalle [0, 1]. On peut y

vérifier qu’elle est correctement majorée par 1 − 2−2−wF .


0

1 − 2−2−wF

0 0,125 0,25 0,5 1

x

ǫrelLNS(x)

Figure 1.14 Comportement de l’erreur relative de représentation dans le système logarithmiqueǫrelLNS(x) sur l’intervalle [0, 1], pour (wI , wF ) = (3, 3).

Dans le cas de l’arrondi vers le haut, l’erreur absolue commise sur le logarithme est d’au plus1 ulp. En appliquant le raisonnement précédent, on a, pour tout nombre réel x ∈ N :

ǫabsLNS(x) < x ·

(22−wF − 1

),

ce qui donne pour l’erreur relative :

ǫrelLNS(x) < 22−wF − 1.

Cette quantité 22−wF − 1 tend aussi vers 2−wF log 2 lorsque la précision wF augmente.Dans le cas de l’arrondi fidèle, l’erreur sur le logarithme est comprise entre−1

2 ulp et 12 ulp. On

a alors la majoration suivante :

ǫabsLNS(x) < x ·

(22−wF −1 − 1

),

d’où la borne sur l’erreur relative :

ǫrelLNS(x) < 22−wF −1 − 1.

Encore une fois, lorsque wF augmente, cette borne tend vers 2−wF−1 log 2. On a donc toujours lefacteur log 2 par rapport à l’erreur maximale en virgule flottante.

Opérations de base

Un des grands avantages du système logarithmique est que certaines de ses opérations debases peuvent se réduire à de simples opérations en virgule fixe sur les logarithmes des opérandes.Ainsi, multiplication et division reviennent respectivement à calculer la somme ou la différencedes deux logarithmes. Sauf en cas de dépassement de capacité, ces deux opérations en virgule fixesont de plus exactes et ne nécessitent pas d’arrondi. De même, le calcul de la racine carrée consisteà diviser le logarithme de l’opérande par 2, ce qui revient à un décalage trivial puis un arronditrès simple.

1.3 FPGA 21

Par contre, l’addition et la soustraction dans le système logarithmique sont au contraire bienplus difficiles à réaliser. En effet, si l’on prend X et Y deux nombres normalisés positifs et ennotant respectivement s et d leur somme et leur différence, on a :

s = X + Y = 2LX + 2LY

= 2LX ·(1 + 2LY −LX

), et

d = X − Y = 2LX − 2LY

= 2LX ·(1 − 2LY −LX

).

On trouve alors :log2 s = LX + log2

(1 + 2LY −LX

), et

log2 d = LX + log2

(1 − 2LY −LX

).

Le calcul de s et d demande alors l’évaluation des fonctions f⊕(r) = log2 (1 + 2r) et f⊖(r) =log2 (1 − 2r). Ces deux fonctions sont cependant difficiles à calculer, et pénalisent ainsi grande-ment l’opérateur d’addition/soustraction dans le système logarithmique.

Conclusion

Le système logarithmique constitue donc une solution alternative à la virgule flottante. Dansles deux systèmes, pour les mêmes valeurs des paramètres wI et wF (pour le système logarith-mique) et wE et wF (pour la virgule flottante), les nombres sont représentés sur des vecteurs de1+wI +wF = 1+wE +wF bits. De plus, la dynamique des nombres représentables ainsi que leurprécision sont très proches. Du point de vue de l’application et de la qualité des calculs, ils sontdonc parfaitement équivalents.Par contre, les algorithmes pour les opérations de base étant radicalement différents, le choix

entre virgule flottante et système logarithmique doit se faire au cas par cas, devant les besoinscalculatoires de chaque application. Intuitivement, une application effectuant un grand nombred’additions ou de soustractions sera plus performante en virgule flottante que dans le systèmelogarithmique. Par contre, si l’application requiert le calcul de nombreuses divisions ou racinescarrées, le système logarithmique sera naturellement plus adapté. Pour appuyer cette intuition,des exemples concrets sont présentés dans le chapitre 3.

1.3 FPGA

Un FPGA (pour Field-Programmable Gate Array) est un circuit intégré composé d’un grandnombre d’éléments logiques programmables reliés entre eux grâce à une matrice de routage elleaussi programmable. Cette structure permet au FPGA d’émuler n’importe quel circuit, à la seulecondition que celui-ci ne soit pas trop gros pour ne pas épuiser les ressources logiques et de rou-tage du FPGA.Cependant, cette souplesse de programmabilité se paye au niveau des performances du cir-

cuit. Bien que les FPGA soient gravés avec la même technologie que les processeurs généralistescadencés à quelques gigahertz, la fréquence d’horloge des FPGA ne dépasse pas quelques cen-taines demégahertz pour les modèles les plus récents. Néanmoins, la grande liberté architecturalepermet de profiter au mieux du parallélisme à grain fin des circuits implémentés, ce qui compenselargement les relativement faibles fréquences atteignables.Cette partie présente ainsi dans la section 1.3.1 les divers domaines d’application des FPGA

actuels. L’architecture de ce type de circuits est donnée section 1.3.2, en détaillant plus particu-lièrement les modèles de FPGA ciblés par les travaux présentés dans ce document. La section


1.3.3 décrit ensuite le mode de programmation des FPGA, du langage utilisé aux divers outilsimpliqués dans la chaîne de conception. Enfin, la section 1.3.4 discute des questions de portabilitéentre les divers modèles de FPGA et argumente les choix que nous avons faits concernant nosopérateurs.

1.3.1 Domaines d’application

Les cellules du FPGA étant indépendantes les unes des autres, elles peuvent très bien effectuerleurs calculs en parallèle. Le FPGA permet ainsi d’optimiser très finement des applications enjouant sur leur parallélisme. On retrouve par conséquent l’utilisation de ce type de processeurdans de nombreux domaines d’applications très calculatoires, comme entre autres le traitement dusignal [HBP+05, PG05, PWSW05], la cryptographie [Beu03, BMP+06, MB06], la bio-informatique[GGL+05, THG05, TMS+06] ou encore plus généralement l’accélération de calculs scientifiques[LKM02, GFA+04, GVH06, WHYC06].Une autre partie de leur domaine d’application est due à leur faible coût. En effet, fondre un cir-

cuit intégré (ou ASIC, pour Application-Specific Integrated Circuit ) demande un investissementfinancier initial très important, qui couvre de l’achat des machines à la réalisation des masquesde gravure du circuit. Même si le coût unitaire de production de chaque circuit est ensuite trèsfaible, l’investissement initial devient rapidement exorbitant pour des circuits spécialisés qui neseront tirés qu’à quelques milliers d’exemplaires. Les FPGA sont aussi des ASIC, mais leur tirageest beaucoup plus important, et donc leur coût bien plus faible. De nombreuses applications de-mandant un circuit spécifique choisissent ainsi la solution du FPGA comme alternative à l’ASICpour réaliser ce circuit.Toujours à cause de leur coût réduit ainsi que de leur souplesse de programmation, les FPGA

sont aussi largement utilisés dans le prototypage rapide. Par mesure de précaution, avant d’en-tamer la gravure d’un circuit intégré, celui-ci est toujours soigneusement testé par simulation demanière à garantir de correction. L’utilisation de circuits FPGA permet ainsi d’accélérer grande-ment cette simulation par rapport à une simulation logicielle.Enfin certains modèles de FPGA sont reconfigurables. Si certains FPGA, comme ceux conçus

par Actel par exemple, sont programmés de manière irréversible grâce à des anti-fusibles [Act05],d’autres reposent sur une technologie SRAM (pour Static Random Access Memory), comme ceuxproposés par Xilinx [Xil05] ou Altera [Alt06b]. Cette technologie permet ainsi de reconfigurer leFPGA autant de fois que nécessaire. Cela est donc utile lorsqu’une erreur est découverte dans uncircuit car il suffit alors de reprogrammer le FPGA avec une version corrigée du circuit.Cette reconfigurabilité ouvre aussi un autre champ d’application, qui est sûrement celui qui

nous intéresse le plus dans le cadre de ce document. De plus en plus de fabriquants de serveursde calculs se mettent en effet à intégrer des FPGA sous la forme de coprocesseurs reconfigurablesdans leurs calculateurs, comme le Cray XD-1 [Cra05] ou, chez SGI, les lames RASC pour la familledes calculateurs Altix [Sil05]. Le FPGA, bénéficiant ainsi d’un lien privilégié avec le processeur,peut être reconfiguré à la volée selon les besoins de l’application en cours d’exécution et sert doncd’accélérateur de calculs dédié.

1.3.2 Architecture

Vue d’ensemble

Les cellules logiques d’un FPGA (aussi appelées PE, pour Processing Elements) sont regrou-pées en îlots, eux-mêmes répartis régulièrement suivant une grille rectangulaire. Chaque îlot estcomposé généralement de quatre, huit ou seize cellules logiques, ainsi que d’un routeur (switch

1.3 FPGA 23

box) programmable réalisant la connexion entre les entrées et sorties des cellules logiques et lamatrice de routage.Cette matrice de routage couvre elle aussi toute la surface du FPGA, sous la forme de pistes

horizontales et verticales. Certaines de ces pistes relient des îlots voisins, alors que d’autres tra-versent tout le FPGA pour permettre de relier deux îlots distants l’un de l’autre. Les switch boxessituées au niveau de chaque îlot réalisent les connexions nécessaires entre ces différents fils.De plus, généralement, des blocs de mémoire dédiés (RAM blocks) sont répartis sur la surface

du FPGA. Connectés à la matrice de routage, ces blocs offrent un espace mémoire confortableutilisable par la logique programmable voisine.Enfin, pour permettre au FPGA de communiquer avec le monde extérieur, des cellules d’en-

trée/sortie (I/O blocks) sont disposées sur tout le pourtour du circuit et elles aussi reliées à lamatrice de routage.La figure 1.15 présente sur la gauche une vue simplifiée de la surface d’un FPGA type, sur

lequel on peut distinguer les cellules d’entrée/sortie, les blocs de mémoire, ainsi que les îlots et lamatrice de routage. Un de ces îlots est représenté plus en détails sur la droite.

Swit h boxPEPE PEPE

Matrice de routageRAM blocksI/O blocks

Figure 1.15 Architecture générale d’un FPGA et détail d’un îlot.

Le modèle de FPGA que nous utilisons comme cible de tous les travaux présentés dans cedocument est un Virtex-II 1000 (speedgrade -4, le plus lent), produit par Xilinx [Xil05]. Selon laterminologie propre à ce constructeur, les îlots sont appelés CLB (pourConfigurable Logic Blocks).Chaque CLB est composé de quatre slices répartis sur deux colonnes, chaque slice étant composéà son tour de deux cellules logiques disposées en colonne. Cette organisation en colonnes permetd’implémenter efficacement des additionneurs grâce à des chaînes de propagation de retenuerapides, comme présenté plus loin.La figure 1.16 présente ainsi l’organisation des quatre slices composant un CLB de Virtex-II,

ainsi que les deux cellules logiques de chacun de ces slices. Les deux chaînes de propagation deretenue dédiées sont aussi représentées.Dans le cas du Virtex-II 1000, la matrice de logique programmable est de 40 × 32 = 1280 CLB,

soit 5120 slices, soit enfin 10240 cellules logiques.

Cellules logiques

Les cellules logiques d’un FPGA consistent en général simplement d’une partie calculatoireet d’une partie de mémorisation. La partie calculatoire est assurée par une table (Look-Up Table,ou LUT) avec n bits d’adresse et 1 bit de sortie. Quant à la partie de mémorisation, il s’agit d’unregistre flip-flop contrôlé par un signal horloge, noté généralement clk.


CLB

Chaînes de retenue

SlicesSwit h box PEPEPEPE

PEPEPEPE

Figure 1.16 Structure d’un îlot (CLB) sur Virtex-II.

La table est donc une petite mémoire de 2n mots de 1 bit, adressée par n bits provenant dela matrice de routage par l’intermédiaire de la switch box. Une LUT permet donc d’implémen-ter n’importe quelle fonction booléenne ayant jusqu’à n variables, grâce à la table de vérité decette fonction. Le résultat de cette table peut soit être réinjecté directement dans la matrice de rou-tage pour ensuite être propagé vers une autre cellule logique du FPGA, soit être mémorisé par leregistre sur un front montant de l’horloge avant d’être redirigé par la switch box.Sur la plupart des FPGA actuels, n est fixé à 4 bits [SRCL92]. Comme nous le verrons par la

suite, les cellules logiques que l’on trouve sur les modèles de FPGA récents sont plus complexesque les cellules présentées ici. Cependant, elles partagent toutes cette structure basée autour d’uneLUT et d’un registre.La figure 1.17 représente un slice de Virtex-II et ses deux cellules logiques. La cellule du bas

implémente la fonction booléenne F (X1,X2,X3,X4) et celle du haut la fonction G(Y1, Y2, Y3, Y4).On peut donc observer les deux LUT sur la gauche du slice, ainsi que les deux registres correspon-dants sur la droite. Les sorties directes des deux tables sont respectivement r et s, et les signaux r′

et s′ représentent les sorties des registres.Les parties grisées sur la figure correspondent à de la logique additionnelle servant à d’autres

fonctionnalités spécifiques qui seront détaillées dans les paragraphes suivants.

Multiplexeurs

Comme nous l’avons vu, si les LUT d’un FPGA sont adressées sur n bits, il est alors pos-sible d’implémenter des fonctions booléennes ayant jusqu’à n variables. L’implémentation d’unefonction à n+1 variables requiert alors un multiplexeur supplémentaire d’après le théorème d’ex-pansion de Shannon :

F (X1, . . . ,Xn,Xn+1) =

{F0(X1, . . . ,Xn) siXn+1 = 0,

F1(X1, . . . ,Xn) sinon,

1.3 FPGA 25

0 1

0 1 10

10clk

G

F

Y1

Y2

Y3

Y4

X1

X2

X3

X4

S ′S

R′R

Figure 1.17 Implémentation des fonctions booléennes F et G à 4 variables sur les deux LUT d’unslice.

avec les fonctions F0 et F1 implémentées sur une LUT chacune :

F0(X1, . . . ,Xn) = F (X1, . . . ,Xn, 0), et

F1(X1, . . . ,Xn) = F (X1, . . . ,Xn, 1).

En considérant la structure des cellules logiques présentée plus haut, le multiplexeur final néces-site l’utilisation d’une troisième LUT, chargée de sélectionner le résultat entre F0(X1, . . . ,Xn) etF1(X1, . . . ,Xn) selon la valeur deXn+1.Pour économiser cette dernière LUT, certains modèles de FPGA intègrent des multiplexeurs

dédiés, permettant de sélectionner une des sorties de deux LUT voisines en fonction de la va-leur d’un signal spécifique. Il est même possible dans certains cas de recommencer l’opérationrécursivement sur plusieurs étages de multiplexeurs.Sur les Virtex-II de Xilinx, on trouve ainsi quatre étages de multiplexeurs. Ces multiplexeurs

permettent donc d’implémenter des fonctions à 5 variables sur un slice, à 6 variables sur deuxslices voisins sur une même colonne, à 7 ou 8 variables sur un CLB et deux CLB respectivement.Dans tous les cas, la sortie de chaque multiplexeur peut-être redirigée vers la matrice de routage,directement ou bien à travers un registre. Un exemple pour une fonction à 5 variables est donnéfigure 1.18.À partir de 9 variables, il faut par contre utiliser des LUT additionnels pour réaliser les étages

de multiplexeurs supplémentaires. Cela entraîne aussi une perte d’efficacité en terme de délai del’opérateur, car les signaux doivent alors emprunter la matrice de routage, qui est considérable-ment plus lente que les fils dédiés reliant les multiplexeurs à l’intérieur des CLB. Sur Virtex-II, ilfaut donc autant que possible se limiter à des fonctions booléennes à 8 variables.

Additionneurs rapides

La structure des cellules logiques vue précédemment ne permet pas d’implémenter efficace-ment un additionneur, car les LUT n’ont qu’un seul bit en sortie, alors que l’addition de deux bitsgénère non seulement un bit de sommemais aussi un bit de retenue. De plus, la propagation de laretenue (ou bien des signaux generate et propagate dans le cas d’un additionneur préfixe) seraittrès lente si elle devait se faire par la matrice de routage.


0 1 10

0 1 10

clk

F1

F0

X4

X2

X3

X1

X4

X2

X3

X1

X5

R′R

Figure 1.18 Implémentation sur un slice d’une fonction booléenne F à 5 entrées en utilisant unmultiplexeur dédié.

Pour ces raisons, du matériel supplémentaire est dédié sur les FPGA actuels pour optimiserle calcul des additions et soustractions. Certains proposent donc de la logique additionnelle danschaque PE permettant le calcul de la somme et de la retenue ainsi que des ressources de routagedédiées pour une propagation rapide de cette retenue. C’est par exemple le cas de toute la gammedes Virtex et Spartan de Xilinx ou bien des Stratix II d’Altera [Xil05, Alt06a]. On peut aussi trouverd’autres types d’additionneurs, comme par exemple sur le Stratix d’Altera qui permet d’implé-menter des additionneurs à sélection de retenue (carry-select adders) [Alt06a].L’architecture des FPGA Virtex-II utilise ainsi des chaînes de propagation de retenue. Chaque

chaîne relie l’ensemble des cellules logiques d’une même colonne, et permet donc de propager laretenue sur toute la hauteur du circuit.La figure 1.19 présente un additionneur 2 bits réalisé sur un slice de Virtex-II. Les deux opé-

randes sont X = X(1)X(0) et Y = Y(1)Y(0). On note R leur somme (R′ en sortie des registres) etenfin Cin et Cout les retenues entrante et sortante respectivement.Pour chaque cellule logique, la porte ET supplémentaire calcule le signal generate Gi pour les

bits X(i) et Y(i) des opérandes, alors que la LUT calcule le signal propagate Pi correspondant :

Gi = X(i) · Y(i), et

Pi = X(i) ⊕ Y(i).

La retenue sortante est donc soit une propagation de la retenue entrante soit une retenue générée.La sélection est effectuée par le multiplexeur contrôlé par Pi. Enfin, une porte XOR (OU exclusif)additionnelle calcule R(i) la somme des deux bits des opérandes et de la retenue entrante.

Blocs de mémoire

Comme mentionné précédemment, les FPGA embarquent aussi des blocs de mémoire dequelques kilobits. Ces blocs sont reliés à la matrice de routage et peuvent donc être accédés parn’importe quelle partie du circuit. Sur les FPGA actuels, les blocs de mémoire ont généralementdeux ports (dual-port memory), permettant deux accès concurrents. Les deux ports supportentmême la plupart du temps des tailles de mots différentes.

1.3 FPGA 27

clk

Cout

Cin

X(1)Y(1)

X(0)Y(0) R′

(0)

R(0)

R′(1)

R(1)0 1

0 1

10

10

Figure 1.19 Additionneur 2 bits implémenté sur un slice grâce à la chaîne de propagation deretenue rapide.

Ainsi, les Virtex-II possèdent un certain nombre de RAM blocks de 18 Kbits répartis en co-lonnes sur la surface du circuit. Ces blocs sont effectivement dual-port et chacun des port sup-porte indépendamment des modes d’adressage allant de 214 = 16 Kmots de 1 bit à 29 = 512motsde 36 bits (dont 4 bits de parité). Le Virtex-II 1000 utilisé dans le cadre des travaux présentés iciintègre ainsi 40 RAM blocks.

Fonctionnalités supplémentaires

Les modèles de FPGA récents offrent un grand nombre d’autres fonctionnalités, parmi les-quelles :

Arbres de distribution d’horloge Devant le nombre de cellules logiques et donc de registres em-barqués dans les FPGA, le signal d’horloge contrôlant ces registres doit être capable de sup-porter une sortance (fanout ) très importante tout en assurant une parfaite synchronisationsur tout le circuit. Cela est clairement impossible à réaliser en utilisant la matrice de routage.Les FPGA possèdent donc des arbres de routage dédiés à la distribution de ce signal d’hor-loge. On trouve généralement plusieurs arbres de distribution sur un seul FPGA, pour per-mettre d’avoir différents domaines d’horloge sur un même circuit. Le Virtex-II 1000 utilisésupporte ainsi jusqu’à 8 domaines d’horloge.

Petits multiplieurs Pour permettre l’implémentation efficace de circuits très calculatoires et mas-sivement parallèles, comme on en trouve en traitement du signal ou en traitement d’images,les générations actuelles de FPGA embarquent toutes de petitsmultiplieurs entiers. Cesmul-tiplieurs, accessibles par la matrice de routage, permettent donc d’accélérer les calculs, maissurtout de réduire grandement le nombre de cellules logiques utilisées par le circuit.La famille des Virtex-II de Xilinx propose ainsi des multiplieurs 18×18 bits. Ces multiplieurspartagent les mêmes ressources de routage que les RAM blocks de 18 Kib : leur utilisationest donc mutuellement exclusive. Le Virtex-II 1000 possède pour sa part 40multiplieurs.

Blocs DSP Les générations les plus récentes de FPGA proposentmême des blocs DSP (pourDigi-tal Signal Processing) dédiés, comme leur nom l’indique, au traitement du signal. Ces blocs


sont généralement composé d’un multiplieur et d’un accumulateur (MAC, pourMultiplierand ACcumulator et permettent ainsi de réaliser des filtres de manière très efficace.On trouve ce genre de blocs DSP chez les FPGA Stratix et Stratix II d’Altera, ainsi que dansles Virtex-4 et Virtex-5 de Xilinx. Par contre, les Virtex-II n’en possèdent pas.

Cœurs de processeurs RISC Enfin, devant l’utilisation croissante des FPGA pour l’implémenta-tion de systèmes embarqués comme les SoC ou les NoC (pour System-on-Chip etNetwork-on-Chip respectivement), certains modèles de FPGA intègrent directement un ou plusieurscœurs complets de processeurs RISC. Ainsi, les Virtex-II Pro et Virtex-4 de Xilinx embarquentjusqu’à quatre cœurs de PowerPC 405.Pour les FPGA qui sont dépourvus de tels processeurs, tels les Virtex-II, les constructeursproposent des solutions softcores, comme le MicroBlaze de Xilinx ou le NIOS II d’Altera,véritables processeurs implémentés dans la matrice de cellules logiques.

1.3.3 Programmation

Si cette section détaille plus particulièrement le flot de conception et de programmation desFPGA, il est important de noter qu’une grande partie est commune avec le flot de conceptionsur ASIC. Cela signifie ainsi que tout les opérateurs présentés dans cette thèse, bien qu’ils ciblentles circuits FPGA, peuvent aussi bien être implémentés sur ASIC, au prix d’un simple reciblagetechnologique qui sera détaillé au cas par cas des opérateurs.

Description des circuits

Les circuits présentés dans ce document sont des implémentations directes d’algorithmes. Ce-pendant, si ces algorithmes peuvent facilement être décrits grâce à n’importe quel langage deprogrammation impératif classique, cela n’est pas du tout le cas des circuits. En effet, l’implé-mentation matérielle d’un algorithme fait appel à des notions temporelles très fortes, comme laconcurrence et la synchronisation, qui ne sont pas naturelles dans les langages classiques. Il fautdonc pour réaliser un circuit recourir à un langage de description dematériel ouHDL, pourHard-ware Description Language, qui sera capable d’exprimer explicitement ces notions temporelles.Il existe de nombreux HDL, parmi lesquels on trouve VHDL, Verilog et SystemC pour les

plus connus et utilisés. Si SystemC est plus orienté vers la modélisation de systèmes complexescomposés de plusieurs processus concurrents, VHDL et Verilog sont quant à eux bien adaptésà la description d’opérateurs arithmétiques comme ceux présentés dans ce document, ainsi qu’àleur intégration dans des circuits plus importants. Nous avons ainsi choisi pour nos opérateursd’utiliser le langage VHDL.Le VHDL, ou Very-High-Speed Integrated Circuit Hardware Description Language, était à

l’origine destiné à documenter de manière formelle la structure et le comportement de circuitsintégrés. Ce n’est que par la suite que furent développés d’abord des simulateurs logiciels, puisenfin des synthétiseurs pour ce langage. VHDL fut décrit par le standard IEEE 1076 en 1987, puisrévisé successivement en 1993 et 2000. Il est désormais l’un des HDL les plus utilisés, tant parl’industrie que par le monde académique.En VHDL, l’entité de base est le composant (aussi appelé entité ). Un composant est représenté

par son interface extérieure, qui définit ses ports d’entrée et de sortie, ainsi que son architectureinterne. L’architecture d’un composant définit à son tour les sous-composants qui la constituent etles fils qui les relient. Un circuit est alors décrit comme un composant, lui-même constitué d’autrescomposants, et ainsi de suite jusqu’à arriver aux composants de base.Cette représentation hiérarchique permet d’ajuster le niveau de détails nécessaires à la des-

cription d’un circuit. Pour la simulation d’un système complet, on peut ainsi se contenter d’une

1.3 FPGA 29

description de haut niveau, où les composants sont décrits par leur comportement, c’est-à-direleur réponse aux stimulations extérieures. De l’autre côté du spectre, lorsque l’on souhaite repré-senter un circuit synthétisable, on peut détailler bien plus la description, en descendant jusqu’auxportes logiques. Cette description structurelle permet ainsi d’avoir un meilleur contrôle sur l’im-plémentation finale du circuit, et donc sur d’éventuelles optimisations de ce circuit. Il convientcependant d’éviter d’optimiser trop un circuit au niveau de sa description en VHDL sous peinede perdre en portabilité, comme nous le verrons par la suite.

Implémentation

La description VHDL d’un circuit subit toute une suite de transformations avant que ce circuitsoit effectivement configuré sur un FPGA.

Synthèse L’étape de synthèse consiste à lire la description VHDL du circuit pour en extraire toutela structure logique. Lorsque des composants de ce circuit sont décrits de manière compor-tementale, c’est le rôle du synthétiseur d’inférer la logique nécessaire à la réalisation descomportements spécifiés. Cette tâche est d’ailleurs possiblement très difficile et donc parfoismal supportée.Un autre rôle du synthétiseur est d’appliquer diverses optimisations logiques au circuit. Ilcherche ainsi à minimiser toutes les expressions logiques utilisées par ce circuit.Enfin, le synthétiseur produit une netlist, c’est-à-dire une liste de fils et de portes logiques.

Mapping La netlist du circuit est ensuite adaptée aux primitives logiques du FPGA cible. Cetteétape de ciblage technologique permet ainsi de passer d’une description structurelle géné-rique à une description spécialisée pour une architecture précise. Les éléments de base nesont alors plus de simples portes logiques mais des cellules programmables du FPGA.

Placement et routage La phase de mapping ayant identifié les ressources logiques nécessaires àl’implémentation d’un circuit, la tâche de placement/routage consiste alors à disposer etconnecter ces ressources sur la surface du FPGA. Il est possible de donner au placeur/rou-teur des contraintes spatiales ou temporelles, pour fixer par exemple la position des portsd’entrée/sortie du circuit ou bien une période d’horloge maximale.À l’issue de l’étape de placement/routage, le circuit obtenu est tel qu’il sera programmé surle FPGA. C’est sur ce modèle que sont calculées les estimations de surface et de latence ducircuit.

Configuration Enfin, la dernière étape avant la programmation effective du FPGA consiste à gé-nérer un bitstream. Ce bitstream est en fait un fichier contenant tous les bits de configurationdu FPGA, construit pour correspondre parfaitement au circuit décrit lors du placement/rou-tage.Une fois le bitstream créé, il ne reste plus qu’à le télécharger sur le FPGA grâce à une inter-face dédiée. Le FPGA restera ainsi configuré tant qu’il sera sous tension, ou bien lorsqu’unautre circuit y sera programmé suivant le même procédé.

Nous avons utilisé pour les travaux présentés ici la version 7.1.04i d’ISE, l’environnement dedéveloppement fourni par Xilinx. Cette suite logicielle inclut notamment le synthétiseur XST, ainsique tous les outils évoqués précédemment.

Simulation logicielle

La simulation logicielle d’un circuit est une étape essentielle de sa conception. Il faut en effets’assurer que celui-ci fonctionne correctement avant de le configurer sur le FPGA. La simulationpermet ainsi de fournir au circuit des vecteurs de test en entrée, puis de vérifier que le circuit


se comporte de la manière prévue. Dans le cas des opérateurs arithmétiques présentés dans cedocument, cela revient donc juste à vérifier la correction des résultats calculés.Bien entendu, la simulation ne garantit pas la correction du circuit. Mis à part pour de petits

opérateurs, il est en effet impossible de réaliser une simulation exhaustive à cause de la lenteur dela simulation logicielle. Il faut donc essayer de choisir des vecteurs de test adaptés à l’opérateurpour couvrir le mieux possible les différents cas de figure.Le simulateur logiciel utilisé pour nos opérateurs est l’édition gratuite de ModelSim Xilinx

Edition III, version 6.0a, développée par ModelTech et munie des bibliothèques de composants deXilinx.

Simulation matérielle

Comme mentionné plus haut, la simulation logicielle est bien trop lente pour pouvoir réaliserdes tests exhaustifs. Il est toutefois envisageable, pour certains opérateurs, d’effectuer ces tests enutilisant une carte de développement pour FPGA, munie de ports d’entrée/sortie rapides. Cela apar exemple été le cas pour les opérateurs présentés dans le chapitre 4.

1.3.4 Portabilité

Comme nous avons pu le voir dans la section 1.3.2, de nombreux modèles de FPGA existent.Si ces modèles partagent les caractéristiques principales communes à tous les FPGA (cellules lo-giques et matrice de routage configurables, blocs de mémoire), les caractéristiques mêmes de ceséléments de base diffèrent grandement d’un modèle à un autre. De même, la présence ou nonde petits multiplieurs câblés ou bien de blocs DSP est encore un facteur supplémentaire pouvantentraver la portabilité d’un circuit.Pour tenter de rendre nos travaux utilisables sur le plus grand nombre d’architectures de

FPGA possibles, nous avons donc dû nous affranchir des spécificités propres à uniquement cer-tains modèles. Par conséquent, les opérateurs présentés dans ce document ne font aucune hypo-thèse sur le FPGA cible sur lequel ils vont être implémentés.Ainsi, par exemple, si un opérateur requiert une multiplication entière, celle-ci sera simple-

ment exprimée en VHDL par l’opérateur * : cette abstraction de l’architecture sous-jacente dumultiplieur laisse le soin au synthétiseur de choisir la manière la plus efficace pour réaliser unemultiplication sur le FPGA cible. Cela signifie donc que la portabilité ne peut être atteinte qu’enretardant le plus loin possible la spécialisation technologique du circuit, déléguant ainsi le plusgros de cette tâche au synthétiseur.

2 CHAPITRE 2

Fonctions élémentaires en virgule fixe

De nombreuses applications demandent l’évaluation en matériel de fonctions numériques :fonctions trigonométriques pour des algorithmes DSP, inverse et racine carrée inverse pour calcu-ler les valeurs initiales des algorithmes de Newton-Raphson ou Goldschmidt dans le cadre de ladivision ou de la racine carrée [Mul05a, DSM95, DSM97, PB02], exponentielle et logarithme pourcertains calculs scientifiques ou bien pour le système logarithmique [DdD03], etc... Demême, pourl’évaluation d’une fonction composée (telle que log2 (1 + 2x) par exemple), il est souvent plus ef-ficace de l’implémenter comme un opérateur dédié à part entière plutôt que sous la forme d’unecombinaison d’opérateurs successifs correspondant à chacune de ses sous-fonctions (ici une expo-nentielle, une addition et un logarithme).Des méthodes spécifiques existent pour implémenter la plupart des fonctions élémentaires.

Par exemple, l’algorithme CORDIC et ses variations permettent de calculer fonctions trigonomé-triques ainsi que les fonctions exponentielle et logarithme. Cela est aussi le cas pour la plupartdes fonctions composées habituelles, comme en témoignent par exemple les divers articles surl’implémentation la fonction log2 (1 + 2x) nécessaire à l’addition dans le système logarithmique[SA75]. Cependant, ces méthodes spécifiques ont généralement des contraintes bien particulières.Ainsi, les algorithmes de type CORDIC produisent des opérateurs très petits mais lents. De plus,le travail de développement nécessaire pour parvenir à de telles solutions est souvent lui aussispécifique et difficilement adaptable à d’autres fonctions.Une alternative est d’utiliser une méthode générale d’implémentation qui puisse être adaptée

aisément à n’importe quelle fonction. La plus simple de ces méthodes est bien évidemment detabuler toutes les valeurs prises par une fonction sur l’intervalle d’entrée demandé. Cependant, lecoût matériel de cette solution croît demanière exponentielle avec la taille en bits de son argumentd’entrée.On peut réduire ce coût en utilisant une approximation polynomiale ou polynomiale par mor-

ceaux de la fonction. Cela demande par contre l’utilisation d’un ou plusieurs multiplieurs quiviennent augmenter la latence de l’opérateur. On trouve ainsi dans la littérature des exemplesd’approximations linéaires (ordre 1) comme [DSM97, Tak98, LLVC03], quadratiques (ordre 2)[Far81, PBM01, CWC01] ou encore cubiques [JL95]. Les travaux présentés dans ce chapitre tententde généraliser ces différentesméthodes tout enminimisant autant que possible le lourd impact desmultiplieurs grâce à une étude précises des différents compromis entre surface, délai et précisiondes opérateurs. La philosophie est ici de ne jamais calculer avec plus de précision que nécessaire.Ces travaux peuvent aussi être considérés comme une extension des précédents travaux sur

les méthodes à base de tables et additions [DSM95, SS99, Mul99, dDT05] utilisant une approxima-tion polynomiale par morceaux du premier ordre de la fonction. Dans ces méthodes, l’évaluationdu terme d’ordre 1 économise le coût d’un multiplieur en tabulant directement les valeurs de ce

32 Chapitre 2. Fonctions élémentaires en virgule fixe

terme. L’opérateur ainsi réalisé n’est composé que d’accès à des tables et d’additions, le rendanttrès rapide. Partant de ces travaux et nous inspirant aussi de [DdDM02], nous avions déjà proposéla méthode SMSO (pour Single-Multiplier Second-Order method ), reposant sur une approxima-tion polynomiale par morceaux d’ordre 2 ne nécessitant qu’un seul petit multiplieur [DdD04]. Ici,le terme “petit” signifiant que les tailles des opérandes et du résultat de ce multiplieur sont bienplus petites que la précision requise.Le développement de la méthode présentée ici fut largement motivée par les constats succes-

sifs que la méthode multipartite est généralement plus rapide qu’une tabulation directe et que laméthode SMSO présente elle-même de meilleures performances que la méthode multipartite. Eneffet, bien que le chemin critique d’un opérateur conçu selon la méthode multipartite comporteune lecture de table ainsi que plusieurs additions, l’évaluation de la même fonction par une seulelecture de table est plus lente, pour la simple raison que cette unique table est bien plus grande, etdonc son accès plus long, que les tables de la méthode multipartite. De la même manière, le coûtdu petit multiplieur de la méthode SMSO est compensé par une réduction encore plus importantede la taille des tables par rapport à la méthode multipartite, ce qui participe encore à accélérerl’opérateur.Notre nouvelle méthode, appelée HOTBM pour Higher-Order Table-Based Method, a donc

pour objectif d’étudier et d’exploiter les techniques utilisées avec succès par les méthodes mul-tipartite et SMSO, tout en les généralisant pour les étendre à des approximations d’ordres su-périeurs, permettant ainsi d’atteindre de plus grandes précisions. Une implémentation de cetteméthode sous forme d’un générateur d’opérateur a aussi été réalisée, pour pouvoir vérifier expé-rimentalement et mettre en application les différents concepts qu’elle manipule.La section 2.1 présente donc d’abord les différentes façons supportées par cette méthode pour

évaluer une fonction donnée f : partant d’une approximation polynomiale de cette fonction jus-qu’au calcul de chacun des termes des polynômes, en passant par le calcul des puissances suc-cessives de l’opérande x. La section 2.2 expose ensuite comment tirer parti de la différence depoids de chacun des termes des polynômes pour ajuster la précision avec laquelle sont calculésces termes, permettant ainsi d’économiser au mieux les ressources matérielles. Après ces deuxparties purement théoriques, la section 2.3 présente de manière détaillée l’architecture des opéra-teurs obtenues grâce à la méthodeHOTBM.Une analyse d’erreur rigoureuse exposée ensuite dansla section 2.4 montre comme garder une trace de toutes les erreurs commises par l’opérateur pourpouvoir garantir la précision requise. Enfin, ce chapitre est conclu par des résultats de placementet routage obtenus pour diverses fonctions à plusieurs précisions, présentés section 2.5. Pour plusde clarté, toutes les notions présentées tout au long de ce chapitre sont appliquées à un seul etmême exemple, permettant ainsi de suivre pas à pas les différentes étapes de construction d’unopérateur.

2.1 Présentation de la méthode HOTBM

2.1.1 Évaluation de fonction

Le problème de l’évaluation matérielle en virgule fixe de fonctions numériques peut être ex-primé de la manière suivante :Étant donnés– une fonction f définie sur un intervalle fini I ⊂ R, et– deux entiers positifs wI et wO représentant les largeurs en bits des mots d’entrée et de sortierespectivement,

on cherche à construire un opérateur matériel calculant une approximation f de la fonction f surl’intervalle I .

2.1 Présentation de la méthode HOTBM 33

Sans perdre de généralité, on peut prendre I = [0, 1[ et la fonction f telle que f(I) ⊆ [0, 1[.L’argument d’entrée x de f sera donc représenté par un nombre en virgule fixeX de wI bits :

X = 0,X(−1)X(−2) · · ·X(−wI ).

De même, le résultat du calcul R = f(X) est représenté en virgule fixe par un mot de wO bits :

R = 0,R(−1)R(−2) · · ·R(−wO).

On souhaite aussi garantir la précision du résultat de l’opérateur. Comme l’arrondi au plusproche est extrêmement difficile d’après le dilemme du fabriquant de tables [LMT98], nous nouscontentons donc ici de garantir un arrondi fidèle, soit la borne suivante sur l’erreur absolue :

ǫabsf = max

X∈I

∣∣∣f(X) − f(X)∣∣∣ < ǫmax

f ,

avec la contrainte sur la borne d’erreur ǫmaxf > 2−wO−1. Généralement, on choisit ǫmax

f = 2−wO ,soit 1 ulp du résultat.

Exemple 2.1 Pour illustrer les notions présentées tout au long de ce chapitre, on considèrel’exemple de la fonction f suivante :

f : x 7→ log2(1 + x), définie sur l’intervalle I = [0, 1[.

On prend de plus wI = wO = 8 bits de précision en entrée comme en sortie, et la contraintesur l’erreur ǫmax

f = 2−wO .La fonction f est représentée figure 2.1.

0

0,25

0,5

0,75

1

0 0,25 0,5 0,75 1

x

f(x)

Figure 2.1 Représentation de la fonction f(x) = log2(1 + x) sur l’intervalle I = [0, 1[.


2.1.2 Approximation polynomiale par morceaux

La méthode présentée ici est basée sur une approximation polynomiale par morceaux : l’in-tervalle d’entrée I = [0, 1[ est partitionné régulièrement en 2α sous-intervalles Ii de la forme[i · 2−α, (i + 1) · 2−α[. Ces sous-intervalles sont indicés par les α bits de poids forts du mot d’en-tréeX.Cela correspond donc à un découpage du mot d’entrée X en deux sous-mots A et B de taille

α et β = wI − α bits respectivement, comme représenté figure 2.2. On a alors :

X = (A + B) · 2−α = A,B · 2−α,

avec :A = A(α−1) · · ·A(1)A(0) = X(−1)X(−2) · · ·X(−α), et

B = 0,B(−1)B(−2) · · ·B(−β) = 0,X(−α−1)X(−α−2) · · ·X(−wI ).

, A0 B

wI

βα

Figure 2.2 Découpage du mot d’entréeX en A et B.

La fonction f est ainsi approchée sur chacun des sous-intervalles Ii par un polynôme de degrén notéPi. Chaque polynôme, obtenu grâce à l’algorithme de Remez [Rem34], est de typeminimax,permettant ainsi de minimiser l’erreur maximale d’approximation du polynôme, c’est-à-dire ladistance maximale entre ce polynôme et la fonction f sur l’intervalle Ii.Le calcul de f(X) revient alors à évaluer le polynôme PA au point 2−αB, ce que nous noterons

P (A, 2−αB). En développant l’expression du polynôme, on obtient alors :

P (A, 2−αB) =n∑

k=0

Kk(A) · Bk · 2−kα. (2.1)

Laméthode présentée ici repose essentiellement sur l’évaluation séparée de chacun des termes(oumonômes) Tk(A,B) = Kk(A) ·Bk · 2−kα suivie d’une sommation pour obtenir le résultat finalf(X) = P (A, 2−αB). Ceci est visible sur l’architecture principale de l’opérateur, présentée figure2.16. Les détails de cette architecture seront toutefois donnés plus loin.

Exemple 2.2 Dans le cadre de notre exemple, en prenant α = 3 bits et β = wI − α = 5bits, on définit ainsi 8 sous-intervalles. On choisit de plus d’effectuer une approximationquadratique, soit n = 2.L’algorithme de Remez nous donne alors les coefficients Kk(A) des 8 polynômes de degré2. On obtient ainsi pour la fonction f(x) = log2(1 + x) les valeurs présentées dans la table2.1. Les termes T0(A,B), T1(A,B) et T2(A,B) correspondants sont représentés figure 2.3.

2.1.3 Tirer parti de la symétrie

Comme 0 ≤ B ≤ 1 − 2−β , on définit∆ comme le milieu de cet intervalle :

∆ =1

2(1 − 2−β).


A K0(A) K1(A) K2(A)

0 0,00002244 . . . 1,43926170 . . . −0,64264436 . . .

1 0,16994105 . . . 1,27994685 . . . −0,51406238 . . .

2 0,32193997 . . . 1,15234858 . . . −0,42055161 . . .

3 0,45944065 . . . 1,04786081 . . . −0,35042332 . . .

4 0,58496953 . . . 0,96073084 . . . −0,29648298 . . .

5 0,70044530 . . . 0,88696786 . . . −0,25410505 . . .

6 0,80735942 . . . 0,82371677 . . . −0,22020577 . . .

7 0,90689428 . . . 0,76888114 . . . −0,19266502 . . .

Table 2.1 Coefficients de l’approximation par morceaux de la fonction f(x) = log2(1 + x).

−0,01

−0,005

0

0

0,1

0,2

0

0,5

1

0 1 · 2−3 2 · 2−3 3 · 2−3 4 · 2−3 5 · 2−3 6 · 2−3 7 · 2−3 1

X

T0(A)

T1(A, B)

T2(A, B)

I0 I1 I2 I3 I4 I5 I6 I7

Figure 2.3 Représentation des termes T0, T1 et T2 pour la fonction f(x) = log2(1 + x).

En écrivant B = (B−∆)+∆, on effectue alors un changement de variable dans l’équation 2.1.


Chaque terme Tk(A,B) peut ainsi être exprimé sous la forme :

Tk(A,B) = Kk(A) · ((B − ∆) + ∆)k · 2−kα

= Kk(A) ·(

k∑

i=0

(k

i

)(B − ∆)k−i∆i

)· 2−kα.

On redistribue alors les termes pour obtenir un polynôme en B − ∆, ce qui donne ainsi lanouvelle expression de l’approximation polynomiale P (A, 2−αB) :

P (A, 2−αB) =n∑

k=0

K ′k(A) · (B − ∆)k · 2−kα,

avec les coefficients :

K ′k(A) =

n−k∑

i=0

(k + i

i

)Kk+i(A) · ∆i · 2−iα.

En notant B′ = B − ∆, on peut remarquer que chaque terme T ′k(A,B) = K ′

k(A) · B′k · 2−kα

présente une symétrie paire ou impaire suivant B′, selon la parité de k. En effet :

K ′k(A) · (−B′)k · 2−kα =

{K ′

k(A) · B′k · 2−kα si k est pair, ou

−K ′k(A) · B′k · 2−kα si k est impair.

On définit alors à partir de B le mot B∗ de β bits :

B∗ = 0,B∗(−1) · · ·B∗

(−β+1)B∗(−β),

avec : {B∗

(−i) = B(−i−1) ⊕(¬B(−1)

)pour 1 ≤ i ≤ β − 1, et

B∗(−β) = 1,

l’opérateur ¬ désignant ici leNON logique. B∗ est ainsi constitué des β − 1 bits de poids faible deB, décalé d’un bit vers la gauche et possiblement inversés lorsque B(−1) = 0, et d’un 1 de poids2−β . B∗ peut donc être obtenu très simplement à partir de B, comme en témoigne l’architectureprésentée figure 2.16.On peut alors remarquer que, lorsque B(−1) = 1, on a :

1

2B∗ = 0,0B(−2) · · ·B(−β)1

= 0,1B(−2) · · ·B(−β) −(2−1 − 2−β−1

)

= B − ∆ = B′.

De même, lorsque B(−1) = 0, cela donne :

1

2B∗ = 0,0

(¬B(−2)

)· · ·(¬B(−β)

)1

= −1,1B(−2) · · ·B(−β)1

= −0,0B(−2) · · ·B(−β) +(2−1 − 2−β−1

)

= ∆ − B = −B′.


On a ainsi la relation suivante entre B′ et B∗ :

B′ = (−1)¬B(−1) · 1

2B∗,

ce qui permet enfin de déduire l’expression du terme T ′k(A,B) :

T ′k(A,B) = K ′

k(A) · B′k · 2−kα

=

{T ∗(A,B∗) si k est pair, ou

(−1)¬B(−1) · T ∗(A,B∗) si k est impair,

avec le terme simplifié :T ∗

k (A,B∗) = K ′k(A) · B∗k · 2−k(α+1).

La figure 2.4 représente la taille et le poids relatifs de B∗ par rapport à B. Le bit de signecorrespond ainsi au signe de B′.

,

1±β−α − 1 1

B∗

A0 B

wI

βα

Figure 2.4 Correspondance entre B et B∗.

Cette transformation, introduite au départ pour l’ordre 1 par Schulte et Stine [SS97], nouspermet ainsi de n’avoir à évaluer chaque terme que sur la moitié de chaque sous-intervalle IA,les valeurs de l’autre moitié pouvant être déduites par symétrie ou anti-symétrie, au prix d’uninverseur et de quelques portes XOR seulement. Ceci est représenté figure 2.5, pour k = 1 et 2respectivement, et avec β = 3 bits.

Exemple 2.3 La transformation précédente s’applique donc aux termes T0, T1 et T2 de notreexemple. On obtient alors les coefficients suivants :

K ′0(A) = K0(A) + K1(A) · ∆ · 2−α + K2(A) · ∆2 · 2−2α,

K ′1(A) = K1(A) + 2K2(A) · ∆ · 2−α, et

K ′2(A) = K2(A).

Les valeurs de ces coefficients sont données table 2.2, et les termes correspondants sontreprésentés figure 2.6.

2.1.4 Calcul des termes

Le calcul de chaque terme T ∗k (A,B∗) étant indépendant des autres, il peut être réalisé de

plusieurs manières différentes. Nous présentons donc ici les diverses méthodes supportées parHOTBM.


0

K2(A) · ∆2

−K1(A) · ∆

0

K1(A) · ∆

0,000 0,001 0,010 0,011 ∆ 0,100 0,101 0,110 0,111

T ′

1(A, B)

T ′

2(A, B)

B =

B′ = −0,0111 −0,0101 −0,0011 −0,0001 0,0001 0,0011 0,0101 0,0111

B∗ = 0,111 0,101 0,011 0,001 0,001 0,011 0,101 0,111

Figure 2.5 Exemples de symétries paire (k = 2, en bas) et impaire (k = 1, en haut), avec β = 3 bits.Seuls les points en noir sont effectivement calculés, les points en blanc étant déduits par symétrie.

A K ′0(A) K ′

1(A) K ′2(A)

0 0,08480935 . . . 1,36144149 . . . −0,64264436 . . .

1 0,24555332 . . . 1,21769711 . . . −0,51406238 . . .

2 0,39016937 . . . 1,10142241 . . . −0,42055161 . . .

3 0,52160073 . . . 1,00542674 . . . −0,35042332 . . .

4 0,64205190 . . . 0,92482860 . . . −0,29648298 . . .

5 0,75321690 . . . 0,85619733 . . . −0,25410505 . . .

6 0,85642564 . . . 0,79705123 . . . −0,22020577 . . .

7 0,95274133 . . . 0,74555061 . . . −0,19266502 . . .

Table 2.2 Coefficients de l’approximation par morceaux de la fonction f(x) = log2(1 + x) aprèsextraction de la symétrie.


−0,002

−0,001

0

−0,08

0

0,08

0

0,5

1

0 1 · 2−3 2 · 2−3 3 · 2−3 4 · 2−3 5 · 2−3 6 · 2−3 7 · 2−3 1

X

T ′

0(A)

T ′

1(A, B)

T ′

2(A, B)

I0 I1 I2 I3 I4 I5 I6 I7

Figure 2.6 Représentation des termes T ′0, T

′1 et T

′2 pour la fonction f(x) = log2(1 + x).

Table simple

La solution la plus simple pour calculer un terme T ∗k (A,B∗) consiste à stocker directement les

valeurs prises par ce terme dans une table. Cette table est adressée par A lorsque k = 0, ainsi quepar les β − 1 bits de poids fort de B∗ lorsque k ≥ 1 (car B∗

(−β) vaut toujours 1).

Exemple 2.4 Pour notre exemple, nous tabulons ainsi le terme d’ordre 0. Cela corresponddonc à une table adressée par A, contenant les 2α = 8 valeurs possibles deK ′

0(A).

Puissance et produit

La seconde solution consiste à calculer tout d’abord B∗k , puis à multiplier le résultat par lecoefficientK ′

k(A) provenant d’une table adressée par A.


Le calcul de B∗k peut aussi être réalisé de diverses manières, présentées dans la section sui-vante. De même, le produit de B∗k parK ′

k(A) offre un large choix d’implémentation détaillé plusbas.

Exemple 2.5 Dans le cadre de notre exemple, les termes T ∗1 (A,B∗) et T ∗

2 (A,B∗) seront tousdeux réalisés de cette manière. Si pour le terme d’ordre 1 il n’y a pas besoin d’opérateurparticulier pour calculer B∗1, le calcul de T ∗

2 (A,B∗) en requiert par contre un pour éleverB∗ au carré.

2.1.5 Élévation à la puissance

Lorsque k ≥ 2, il existe plusieurs méthodes pour évaluer B∗k. Encore une fois, la plus simpleest bien évidemment de tabuler toutes les valeurs de B∗k dans une table adressée par B∗.Une autre solution est de calculer tous les produits partiels impliqués dans l’élévation de B∗

à la puissance k, puis d’en faire la somme. L’intérêt d’une telle méthode est qu’un grand nombrede simplifications peuvent être appliquées au tableau de produits partiels, comme présenté dans[PBM01, EL03].Pour simplifier les notations, on définit 〈i1, i2, . . . , il〉 comme le produit partiel des bits B∗

(−i1),B∗

(−i2), . . ., B∗(−il)

:〈i1, i2, . . . , il〉 = B∗

(−i1) · B∗(−i2) · . . . · B∗

(−il).

On déduit ainsi des propriétés de l’opérateur logique ET les deux identités suivantes :Commutativité Pour toute permutation σ ∈ Sl, on a :

〈i1, i2, . . . , il〉 = 〈iσ(1), iσ(2), . . . , iσ(l)〉,du fait de la commutativité du ET logique : B∗

(−ij)· B∗

(−ij′ )= B∗

(−ij′ )· B∗

(−ij).

On peut ainsi en déduire que :

〈i1, i2, . . . , il〉 + 〈iσ(1), iσ(2), . . . , iσ(l)〉 = 2 · 〈i1, i2, . . . , il〉,ce qui correspond à remplacer ces deux produits partiels par un seul produit partiel de poidsdouble.

Idempotence Lorsque ij = ij′ , on a :

〈i1, i2, . . . , ij , ij′ , . . . , il〉 = 〈i1, i2, . . . , ij , . . . , il〉,puisque B∗

(−ij)· B∗

(−ij′ )= B∗

(−ij)· B∗

(−ij)= B∗

(−ij).

Cette identité permet donc de réduire la taille de certains produits partiels.

Exemple 2.6 Nous choisissons pour le terme d’ordre 2 de notre exemple de calculer B∗2 eneffectuant la somme de ses produits partiels. Comme β = 5 bits, on a :

B∗ = 0, B∗(−1)B

∗(−2)B

∗(−3)B

∗(−4)1.

En élevant au carré, on construit alors le tableau de produits partiels suivant, qui correspondà l’addition de cinq termes :

Poids 2−1 2−2 2−3 2−4 2−5 2−6 2−7 2−8 2−9 2−10

B∗2 = 〈1〉〈2〉〈3〉〈4〉 1+ 〈1, 4〉〈2, 4〉〈3, 4〉〈4, 4〉〈4〉+ 〈1, 3〉〈2, 3〉〈3, 3〉〈4, 3〉〈3〉+ 〈1, 2〉〈2, 2〉〈3, 2〉〈4, 2〉〈2〉+ 〈1, 1〉〈2, 1〉〈3, 1〉〈4, 1〉〈1〉.


Après application des identités, on obtient le tableau simplifié suivant :

Poids 2−1 2−2 2−3 2−4 2−5 2−6 2−7 2−8 2−9 2−10

B∗2 = 〈1, 2〉〈1, 3〉〈1, 4〉〈1〉〈2〉〈3〉 1+ 〈1〉〈2, 3〉〈2, 4〉〈3, 4〉〈4〉+ 〈2〉〈3〉.

L’addition finale est ainsi réduite à trois termes.

2.1.6 Calcul du produit

Découpage et répartition

Le résultat du calcul deB∗k est un mot de kβ bits. Or, comme B∗(−β) vaut 1 par construction, le

bit de poids 2−kβ de B∗k est lui-aussi toujours 1. Il n’est donc pas nécessaire de calculer ce bit. Onconsidère ainsi le mot Sk de kβ − 1 bits comme B∗k privé de ce bit de poids faible :

Sk = B∗k − 2−kβ .

Le produit de B∗k parK ′k(A), noté Qk(A,B∗), devient alors :

Qk(A,B∗) = K ′k(A) · B∗k = K ′

k(A) ·(Sk + 2−kβ

).

En s’inspirant de la technique utilisée pour la méthode multipartite dans le cas k = 1 [dDT05],on peut partitionner Sk en plusieurs sous-mots. Le produit de Sk parK ′

k(A) sera alors développéet distribué en plusieurs sous-produits, avant d’être reconstruit en calculant la somme de tous cessous-produits. L’intérêt est ainsi d’optimiser indépendamment chacun de cesmultiplieurs, commedétaillé plus loin.On découpe donc pour cela le mot Sk en mk sous-mots Sk,j de taille respective σk,j. On note

de plus −ρk,j le poids respectif de chacun de ces sous-mots. Cela donne ainsi :

Sk = Sk,1 · 2−ρk,1 + Sk,2 · 2−ρk,2 + . . . + Sk,mk· 2−ρk,mk

=

mk∑

j=1

Sk,j · 2−ρk,j .

En notant Sk = 0,Sk,(−1)Sk,(−2) · · ·Sk,(−kβ+1), on obtient :

Sk,j = 0,Sk,(−ρk,j−1)Sk,(−ρk,j−2) · · ·Sk,(−ρk,j−σk,j), pour 1 ≤ j ≤ mk.

Comme il s’agit d’une partition, on a de plus les conditions suivantes :

ρk,1 = 0,

ρk,j+1 = ρk,j + σk,j pour 1 ≤ j < mk, etmk∑

j=1

σk,j = ρk,mk+ σk,mk

= kβ − 1.

Une telle partition de Sk est présentée figure 2.7.


,

. . .. ..

0σk,1 σk,2 σk,mk

σk,j

. . . . . .

−ρk,mk

−ρk,3−ρk,2

−ρk,j

kβ − 1

Sk,1 Sk,2 Sk,mkSk,j

Figure 2.7 Découpage du mot Sk en Sk,1, Sk,2, . . ., Sk,mk.

Symétrie

On décide de tirer parti la symétrie impaire du produit, de la même manière que précédem-ment, comme l’illustrent les figures 2.9 et 2.10. On définit à cet effet les valeurs ∆k,j :

∆k,1 =1

2(0 − 2−σk,1), et

∆k,j =1

2(1 − 2−σk,j ) pour 2 ≤ j ≤ mk.

On effectue ainsi les changements de variables Sk,j = S′k,j + ∆k,j, ce qui donne alors :

Sk =

mk∑

j=1

Sk,j · 2−ρk,j

=

mk∑

j=1

(S′

k,j + ∆k,j

)· 2−ρk,j

=

mk∑

j=1

S′k,j · 2−ρk,j +

1

2

mk∑

j=2

2−ρk,j −mk∑

j=1

2−σk,j−ρk,j

.

Or, par définition de la partition de Sk, on sait que ρk,j + σk,j = ρk,j+1 pour j < mk et ρk,mk+

σk,mk= kβ − 1, d’où :

Sk =

mk∑

j=1

S′k,j · 2−ρk,j +

1

2

mk∑

j=2

2−ρk,j −mk−1∑

j=1

2−ρk,j+1 − 2−kβ+1

=

mk∑

j=1

S′k,j · 2−ρk,j − 2−kβ .

En revenant à l’expression de B∗k en fonction de Sk, on obtient finalement :

B∗k = Sk + 2−kβ =

mk∑

j=1

S′k,j · 2−ρk,j ,

ce qui permet de distribuer le produit deB∗k parK ′k(A) en une somme de plusieurs sous-produits

Qk,j(A,Sk,j) = K ′k(A) · S′

k,j de la manière suivante :

Qk(A,B∗) = K ′k(A) · B∗k =

mk∑

j=1

Qk,j(A,Sk,j),


avec Qk,j(A,Sk,j) = K ′k(A) · S′

k,j · 2−ρk,j .Comme on a fait en 2.1.3, on définit alors les mots S∗

k,j à partir de Sk,j :

{S∗

k,1 = 0,Sk,1,(−1)Sk,1,(−2) · · ·Sk,1,(−σk,1)1, et

S∗k,j = 0,S∗

k,j,(−1)S∗

k,j,(−2)· · ·S∗

k,j,(−σk,j+1)1 pour 2 ≤ j ≤ mk,

avec S∗k,j,(−i) = Sk,j,(−i−1) ⊕

(¬Sk,j,(−1)

)pour 1 ≤ i ≤ σk,j − 1 et 2 ≤ j ≤ mk.

On peut alors rapidement prouver les égalités suivantes :

S′k,1 = S∗

k,1, et

S′k,j = (−1)¬Sk,j,(−1) · 1

2S∗

k,j pour 2 ≤ j ≤ mk.

Une représentation graphique des poids et tailles respectifs des S∗k,j par rapport à B∗k et aux

Sk,j est donnée figure 2.8.

,

,

0σk,1 σk,2 σk,mk

σk,j

. . . . . .

1

1

kβ − 1

0

±σk,1 + 1

±σk,2

±

±

σk,mk

.

.

.

..

. ..

σk,j .

−ρk,2 − 1

−ρk,3 − 1

−ρk,j − 1

−ρk,mk− 1

Sk,1 Sk,2 Sk,mkSk,j

Sk

B∗k

S∗k,1

1

1

S∗k,2

1

1

1

S∗k,j

S∗k,mk

Figure 2.8 Correspondance entre les Sk,j et les S∗k,j .

On obtient enfin les expressions suivantes permettant de calculer simplement les produitsQk,j(A,Sk,j) :

{Qk,j(A,Sk,1) = Q∗

k,1(A,S∗k,1), et

Qk,j(A,Sk,j) = (−1)¬Sk,j,(−1) · Q∗k,j(A,S∗

k,j) · 2−ρk,j−1 pour 2 ≤ j ≤ mk,


avec Q∗k,j(A,S∗

k,j) = K ′k(A) · S∗

k,j pour 1 ≤ j ≤ mk.Les figures 2.9 et 2.10 présentent un exemple de décomposition par symétrie pour mk = 3

sous-produits. La première figure représente séparément ces trois sous-produits Qk,1(A,Sk,1),Qk,2(A,Sk,2) et Qk,3(A,Sk,3), et la seconde représente leur somme Qk(A,B∗) = K ′

k(A) · B∗k.

0

K ′

k(A) · 0,001

K ′

k(A) · 0,011

K ′

k(A) · 0,101

K ′

k(A) · 0,111

0

0

Qk,1(A, Sk,1)

Qk,2(A, Sk,2)

Qk,3(A, Sk,3)

Sk,1 = 0,00 0,01 0,10 0,11

S∗

k,1 = 0,001 0,011 0,101 0,111

Sk,2 = 0,00 0,01 0,10 0,11 0,00 0,01 0,10 0,11 . . .

S∗

k,2 = 0,11 0,01 0,01 0,11 0,11 0,01 0,01 0,11 . . .

Sk,3 = 0,0 0,1 0,0 0,1 . . .

S∗

k,3 = 0,1 0,1 0,1 0,1 . . .

Figure 2.9 Exemple de décomposition par symétrie pour le calcul du produitQk(A,B∗), avec kβ =6 bits, mk = 3 sous-produits, σk,1 = σk,2 = 2 bits et σk,3 = 1 bit. Les points noirs correspondentaux points effectivement calculés, les points blancs étant obtenus par symétrie. La somme de cessous-produits est présentée figure 2.10.

Calcul des sous-produits

Chacun des sous-produits Q∗k,j(A,S∗

k,j) = K ′k(A) · S∗

k,j peut être à son tour obtenu grâce àune table adressée par A et S∗

k,j (privé de son bit de poids faible toujours à 1) ou bien calculé àl’aide d’un multiplieur en virgule fixe, le coefficient K ′

k(A) provenant d’une table adressée par Auniquement.Nous choisissons donc d’implémenter les mk,M sous-produits de poids fort en utilisant de

2.2 Adaptation de la précision 45

0

K ′

k(A) · 0,001

K ′

k(A) · 0,011

K ′

k(A) · 0,101

K ′

k(A) · 0,111

0,000001 0,010001 0,010001 0,010001 1,000001

B∗k

Qk(A, B∗)

Figure 2.10 Reconstruction du produit Qk(A,B∗) à partir de ses trois sous-produits Qk,j(A,Sk,j).Les points blancs correspondent au premier sous-produit Qk,1(A,Sk,1) uniquement. Les pointsgris correspondent quant à eux à la somme des deux premiers sous-produits Qk,1(A,Sk,1) +Qk,2(A,Sk,2). Enfin, les points noirs correspondent à la somme des trois sous-produitsQk(A,B∗) = Qk,1(A,Sk,1) + Qk,2(A,Sk,2) + Qk,3(A,Sk,3).

vrais multiplieurs et de tabuler lesmk,T = mk − mk,M sous-produits restants. Ce choix est justifiédans le cadre d’une analyse d’erreur présentée plus loin.

Exemple 2.7 Pour l’exemple de la fonction f(x) = log2(1 + x), nous choisissons de répartirle produit du terme d’ordre 1 sur deux sous-produits. On a doncm1 = 2, avec le découpagesuivant :

(ρ1,1, σ1,1) = (0, 1), et

(ρ1,2, σ1,2) = (1, 3).

Le premier sous-produit sera implémenté grâce à un multiplieur alors que le second seratabulé, soitm1,M = m1,T = 1.Le produit du terme d’ordre 2, quant à lui, sera implémenté grâce à une unique table,adressée par A et S∗

2,1 = B∗2. Ainsi, on a m2 = 1 avec le découpage trivial (ρ2,1, σ2,1) =(0, 2β2 − 1) = (0, 9). On a aussim2,M = 0 etm2,T = 1.

2.2 Adaptation de la précision

La seule erreur commise par la méthode décrite jusqu’à présent est l’erreur due à l’approxima-tion polynomiale par morceaux obtenue par l’algorithme de Remez. Cependant, on peut observerdans l’expression 2.1 que les différents termes de ce polynôme n’ont pas le même poids dansl’addition finale, du fait des différents facteurs de la forme 2−kα. Les termes de poids faible sontdonc calculés avec une précision bien supérieure à celle des termes de poids fort. En partant de ceconstat, nous pouvons dès lors simplifier ces termes en sacrifiant un peu de leur précision pourgagner en surface et en latence.


2.2.1 Moins de bits pour B

Une première solution pour évaluer un terme T ′k(A,B) avecmoins de précision est de n’utiliser

que les βk bits de poids fort de B pour calculer ce terme. On note Bk ce sous-mot de B :

Bk = 0,B(−1)B(−2) · · ·B(−βk).

Intuitivement, cela revient simplement à calculer moins de valeurs de ce terme à l’intérieur dechaque sous-intervalle IA, c’est-à-dire ne pas utiliser la précision complète du mot d’entréeX : ils’agit d’une discrétisation supplémentaire de cette entrée.Il reste alors à évaluer le terme :

T ′k(A,Bk) = K ′

k(A) · B′kk · 2−kα,

avec B′k = Bk − ∆k et∆k = 1

2

(1 − 2−βk

)le point médian de l’intervalle couvert par Bk.

La technique présentée dans la section 2.1.3 pour simplifier le calcul de B′ en fonction de Bs’applique directement àB′

k. On définit ainsi le motB∗k de βk bits, composé des βk−1 bits de poids

faible de Bk, possiblement inversés lorsque Bk,(−1) vaut 0, et d’un 1 de poids 2−βk :

B∗k = 0,B∗

k,(−1) · · ·B∗k,(−βk+1)1,

avec :B∗

k,(−i) = Bk,(−i−1) ⊕(¬Bk,(−1)

)

= B(−i−1) ⊕(¬B(−1)

)

= B∗(−i) pour 1 ≤ i ≤ βk − 1.

On peut alors de la même manière prouver que :

B′k = (−1)¬Bk,(−1) · 1

2B∗

k .

Cela donne finalement l’expression suivante :

T ′k(A,Bk) =

{T ∗(A,B∗

k) si k est pair, ou

(−1)¬Bk,(−1) · T ∗(A,B∗k) si k est impair,

avec le terme :T ∗

k (A,B∗k) = K ′

k(A) · B∗kk · 2−k(α+1).

Du fait du facteur 2−kα, les termes T ′k(A,Bk) sont de moins en moins significatifs alors que k

augmente. Ainsi, intuitivement, on prendra :

βk ≥ βk′ , pour 0 ≤ k < k′ ≤ n.

Exemple 2.8 Dans le cadre de notre exemple, nous choisissons β1 = β = 5 bits pour leterme linéaire T ′

1 et β2 = 4 bits pour le terme quadratique T ′2.

S∗2,1 = B∗2

2 est donc un mot de 8 bits et non plus 10, ce qui permet ainsi de diminuer lenombre de bits adressant la table pour l’unique sous-produitQ2,1(A,S∗

2,1).



Calculer moins de bits

Comme on vient de le voir, seuls les βk bits de poids fort de B sont utilisés pour calculer leterme d’ordre k. Ainsi, dans le cas des termes évalués sous forme puissance et produit, cela signifieque le mot Sk = B∗k

k −2kβk , calculé par l’unité d’élévation à la puissance, n’occupe plus que kβk−1bits.On peut alors décider de dégrader encore plus la précision à ce niveau en réduisant Sk à ses

λk bits de poids fort, avec bien entendu λk ≤ kβk − 1.

Nouveau découpage

Les λk bits de Sk sont alors partitionnés en mk sous-mots Sk,j de la même manière que précé-demment, avec la nouvelle contrainte :

mk∑

j=1

σk,j = λk.

En définissant aussi de manière identique les S′k,j et S

∗k,j en fonction des Sk,j, on retrouve les

expressions suivantes pour les sous-produitsQk,j(A,Sk,j) :

{Qk,j(A,Sk,1) = Q∗

k,1(A,S∗k,1), et

Qk,j(A,Sk,j) = (−1)¬Sk,j,(−1) · Q∗k,j(A,S∗

k,j) · 2−ρk,j−1 pour 2 ≤ j ≤ mk,

avec Q∗k,j(A,S∗

k,j) = K ′k(A) · S∗

k,j pour 1 ≤ j ≤ mk.

Correction de l’erreur commise

La somme des sous-produits nous donne :

Qk(A,B∗k) =

mk∑

j=1

Qk,j(A,Sk,j) = K ′k(A) ·

mk∑

j=1

S′k,j · 2−ρk,j .

En reprenant la définition des S′k,j, on obtient alors :

Qk(A,B∗k) = K ′

k(A) ·(Sk + 2−λk−1

).

Cela nous permet donc d’obtenir l’erreur commise sur le produitQk(A,B∗k) lorsque l’on réduit

Sk à ses λk bits de poids fort :

ǫQk= K ′

k(A) · B∗kk − K ′

k(A) ·(Sk + 2−λk−1

)

= K ′k(A) · ǫSk

,

avec :ǫSk

= B∗kk − Sk − 2−λk−1.

Comme l’objectif de la méthode HOTBM est de maîtriser le comportement de l’erreur maxi-male, cela revient ici à minimiser l’erreur absolue sur Sk :

ǫabsSk=∣∣∣B∗k

k − Sk − 2−λk−1∣∣∣ .


Cas d’une table simple

Dans le cas où l’élévation à la puissance est réalisée par une table adressée par B∗k , on peut

prendre pour Sk la valeur de B∗kk directement tronquée à ses λk bits de poids faible. En effet, cette

troncature nous donne :2−kβk ≤ B∗k

k − Sk ≤ 2−λk − 2−kβk ,

soit :2−kβk − 2−λk−1 ≤ ǫSk

≤ 2−λk−1 − 2−kβk .

Dans ce cas là, la troncature nous permet ainsi d’obtenir une erreur absolue inférieure à 12 ulp

de Sk :ǫabsSk

≤ 2−λk−1 − 2−kβk .

Cas d’un opérateur dédié

Cela se complique un peu dans le cas où Sk est calculé comme une somme de produits partiels,car négliger tous les produits partiels de poids inférieur à 2−λk engendre une erreur importante.On introduit alors un second paramètre noté µk, avec λk ≤ µk ≤ kβk − 1, spécifiant le poids

minimal des produits partiels pris en compte lors de la somme. C’est seulement après cette sommeque le résultat est tronqué à ses λk bits de poids fort. Ceci est représenté figure 2.11.

.. .. ... . .Poids : 2−kβk2−µk2−λk2−32−22−1

µk

λk

Figure 2.11Approximation de la somme des produits partiels avec les paramètres λk etµk. Chaqueproduit partiel est représenté par un point. Les points blancs sont négligés par l’opérateur, les grissont évalués et pris en compte dans le calcul de la somme, mais le résultat final est tronqué aux λk

bits de poids forts, indiqués par les points noirs. Dans cet exemple, k = 2, β2 = 10 bits, λ2 = 11 etµ2 = 15.

Pour calculer l’erreur commise sur Sk, il faut donc d’abord tenir compte des produits partielsde poids inférieur à 2−µk qui ont été négligés par l’opérateur. On note ǫµk

l’erreur commise ainsi.En remarquant de plus que le produit partiel de poids 2−kβk vaut toujours 1 et est toujours négligé,on peut écrire :

ǫµk= ǫ′µk

+ 2−kβk .

La valeur minimale de ǫ′µkest atteinte lorsque tous les bits de B∗

k sont à 0, sauf bien évidem-ment le bit de poids 2−βk qui vaut toujours 1. Dans ce cas, tous les produits partiels, qui sont desconjonctions de bits de B∗

k , valent 0. Cela nous donne donc :

ǫ′µk≥ 0.

De même, la valeur maximale de ǫ′µkest atteinte lorsque les bits deB∗

k valent tous 1, ce qui cor-respond à avoir tous les produits partiels à 1. Compte tenu des réductions appliquées au tableau


des produits partiels, obtenir une formule générale majorant précisément ǫ′µkest extrêmement dif-

ficile. Cependant, lorsque le tableau de produits partiels est connu, il suffit d’additionner le poidsde chacun des produits partiels négligés par l’opérateur.Dans l’exemple de la figure 2.11, pour k = 2, βk = 10 et µk = 15 bits, on a ainsi la majoration

suivante :ǫ′µ2

≤(3 · 24 + 2 · 23

)· 2−kβk = 64 · 2−20 = 2−14.

Si l’on décide ensuite de tronquer le résultat de la somme des produits partiels à ses λk bits depoids fort, l’erreur commise est alors majorée par 2−λk − 2−µk .L’erreur totale ǫSk

commise sur Sk vérifie ainsi l’encadrement suivant :

2−kβk − 2−λk−1 ≤ ǫSk≤ max ǫ′µk

− 2−µk + 2−λk−1 + 2−kβk .

Pour minimiser l’erreur maximale, on rajoute une constante au tableau de produits partiels detelle sorte que l’erreur ǫSk

soit centrée autour de 0. La constante Ck en question est ainsi :

Ck =1

2

(max ǫ′µk

− 2−µk + 2 · 2−kβk)

=1

2max ǫ′µk

− 2−µk−1 + 2−kβk .

Cette constante est ensuite arrondie à µk bits de partie fractionnaire et ses bits à 1 sont ajoutésau tableau de produits partiels pour être pris en compte lors de la somme de ces produits partiels.En reprenant encore l’exemple précédent, on trouve :

Ck = 2−15 − 2−15−1 + 2−20 = 2−16 + 220,

soit, en arrondissant à µk = 15 bits de partie fractionnaire, Ck ≈ 2−15. On rajoute donc un bitsupplémentaire à 1 de poids 2−15 au tableau des produits partiels, comme représenté figure 2.12.

.. .. ... . .Poids : 2−kβk2−µk2−λk2−32−22−1

µk

λk

Figure 2.12 Approximation de la somme des produits partiels avec les paramètres λk et µk, corri-gée par l’ajout d’une constante. Le bit supplémentaire est représenté par un point gris hachuré.

Exemple 2.9 Dans l’exemple de la fonction f(x) = log2(1 + x), les termes d’ordre 1 et 2évaluent B∗k

k comme une somme de produits partiels.Pour le terme linéaire T ′

1, on décide de conserver toute la précision de l’opérateur. Commeβ1 = 5 bits, on prend alors µ1 = λ1 = β1 − 1 = 4 bits, en gardant la partition définieprécédemment.On choisit par contre de dégrader la précision du terme T ′

2. Avec β2 = 4 bits, on a le tableaude produits partiels suivant pour B∗2

2 :

Poids 2−1 2−2 2−3 2−4 2−5 2−6 2−7 2−8

B∗22 = 〈1, 2〉〈1, 3〉〈2, 3〉〈2〉 1

+ 〈1〉〈1〉〈3〉+ 〈2〉.


On prend alors λ2 = 2 et µ2 = 3 bits. L’erreur ainsi commise est recentrée grâce à laconstance C2 = 2−4 + 2−8 ≈ 2−3, ce qui donne le tableau de produits partiels suivant :

Poids 2−1 2−2 2−3

〈1, 2〉〈1, 3〉+ 〈1〉 1.

Le découpage de S2 devient alorsm2 = m2,T = 1 avec (ρ2,1, σ2,1) = (0, 2).

2.2.3 Moins de bits pour A

Approximation du coefficient K ′k(A)

De la mêmemanière qu’on a pu diminuer le nombre de bits deB utilisés pour calculer le termeT ′

k(A,B), on peut aussi choisir de réduire A à ses αk bits de poids fort, notés Ak :

Ak = A(α−1)A(α−2) · · ·A(α−αk).

Cela correspond à utiliser une même valeur du coefficient d’ordre k sur des groupes de 2α−αk

sous-intervalles consécutifs : tous les intervalles de la forme IAkC , avec 0 ≤ C ≤ 2α−αk − 1,

partagent ainsi le même coefficient d’ordre k, noté K ′k(Ak).

On définit ce nouveau coefficient comme la moyenne des extrema du coefficient K ′k(A) sur

l’ensemble des sous-intervalles couverts, de sorte à minimiser l’erreur absolue maximale com-mise :

K ′k(Ak) =

1

2

(min

0≤C≤2α−αk−1K ′

k

(AkC

)+ max

0≤C≤2α−αk−1K ′

k

(AkC

)).

Le terme à calculer devient alors :

T ′k(Ak, Bk) =

{T ∗(Ak, B

∗k) si k est pair, ou

(−1)¬Bk,(−1) · T ∗(Ak, B∗k) si k est impair,

avec :T ∗

k (Ak, Bk) = K ′k(Ak) · B∗k

k · 2−k(α+1).

Le découpage deX en Ak et Bk est représenté figure 2.13.

,0

wI

β

αk βk

Ak

α

Bk

Figure 2.13 Découpage du mot d’entréeX en Ak et Bk.

De la même manière que précédemment, comme un terme T ′k(Ak, Bk) doit être calculé avec

plus de précision qu’un terme d’ordre supérieur, on choisit d’appliquer la contrainte suivante :

αk ≥ αk′ , pour 0 ≤ k < k′ ≤ n.


Termes sous forme puissance et produit

Dans le cas des termes calculés par une élévation à la puissance et un produit, on peut pour-suivre le raisonnement précédent, et n’utiliser que les αk,j bits de poids fort de Ak pour calculerchaque sous-produit Qk,j(A,Sk,j), pour 1 < j ≤ mk, puisque ces sous-produits eux-mêmes ontdes poids différents à cause du facteur 2−ρk,j−1. On prend de plus αk,1 = αk.On note ainsi Ak,j les sous-mots formés des αk,j bits de poids fort de A :

Ak,j = A(α−1)A(α−2) · · ·A(α−αk,j).

Le coefficient, ainsi partagé entre 2α−αk,j sous-intervalles consécutifs, est noté K ′k,j(Ak,j) et

défini, de la même manière que pour les termes tabulés, comme la moyenne des extrema du coef-ficient K ′

k(Ak) sur l’ensemble des sous-intervalles couverts :

K ′k,j(Ak,j) =

1

2

(min

0≤C≤2αk−αk,j−1

K ′k

(Ak,jC

)+ max


K ′k

(Ak,jC

)).

Chaque sous-produitQk,j(A,Sk,j) devient ainsi :

Qk,j(Ak,1, Sk,1) = Q∗k,1(Ak,1, S

∗k,1), et

Qk,j(Ak,j, Sk,j) = (−1)¬Sk,j,(−1) · Q∗k,j(Ak,j, S

∗k,j) · 2−ρk,j−1 pour 2 ≤ j ≤ mk,

avec :Q∗

k,j(Ak,j, S∗k,j) = K ′

k,j(Ak,j) · S∗k,j , pour 1 ≤ j ≤ mk.

Chaque sous-produit est alors évalué en n’utilisant que les αk,j bits de poids fort de A. Lors-qu’il est calculé grâce à un vrai multiplieur, le coefficient K ′

k,j est adressé par ce sous-mot Ak,j

uniquement. De même, lorsque le sous-produit est directement tabulé, cette table est alors adres-sée parAk,j et S∗

k,j. Dans les deux cas, le nombre de bits d’adresse de la table est diminué, réduisantainsi la taille de cette table.Le découpage du mot d’entréeX suivant les Ak,j et Bk est représenté figure 2.14.

,0

wI

βk

BkAk,mk

αk,1αk,2

. . .

βα

αk,mk

Ak,1

Ak,2

.. .

Figure 2.14 Découpage du mot d’entréeX en plusieurs Ak,j et Bk.

Le poids relatif des différents sous-produits nous permet de plus de déduire la contraintesuivante, permettant de diminuer la précision des sous-produits les moins significatifs :

αk,j ≥ αk,j′, pour 1 ≤ j < j′ ≤ mk.

On note enfin l’expression du terme d’ordre k comme la somme de ses sous-produits :

T ∗k (Ak, B

∗k) =

mk∑

j=1

Qk,j(Ak,j , Sk,j)

· 2−k(α+1),


ce qui donne :

T ′k(Ak, Bk) =

{T ∗(Ak, B

∗k) si k est pair, ou

(−1)¬Bk,(−1) · T ∗(Ak, B∗k) si k est impair.

Exemple 2.10 Dans le cadre de notre exemple, le terme constant T ′0 étant le plus significatif,

il sera calculé avec une précision maximale. On a donc α0 = α = 3 bits.De même, on choisit aussi d’utiliser α1 = α = 3 bits pour le terme T ′

1. Ce terme étantdistribué sur deux sous-produits, on prend alors α1,1 = 3 bits pour le sous-produit de poidsfort mais seulement α1,2 = 2 bits pour celui de poids faible.Enfin, pour le terme d’ordre 2, qui peut être calculé avec bien moins de précision, on choisitde n’utiliser que α2 = 1 bit. Ce terme étant calculé comme un seul sous-produit, on a doncaussi α2,1 = α2 = 1 bit.Les valeurs des coefficients K ′

0, K′1,1, K

′1,2 et K

′2,1 pour chacun des termes et de leurs sous-

produits sont données table 2.3. Les termes correspondants T ′0, T

′1 et T ′

2 sont représentésfigure 2.15.

A K ′0(A0) K ′

1,1(A1,1) K ′1,2(A1,2) K ′

2,1(A2,1)

(α0 = 3 bits) (α1,1 = 3 bits) (α1,2 = 2 bits) (α2,1 = 1 bit)0 0,08480935 . . . 1,36144149 . . .

1,28956930 . . .−0,49653384 . . .

1 0,24555332 . . . 1,21769711 . . .2 0,39016937 . . . 1,10142241 . . .

1,05342457 . . .3 0,52160073 . . . 1,00542674 . . .

4 0,64205190 . . . 0,92482860 . . .0,89051297 . . .

−0,24457400 . . .5 0,75321690 . . . 0,85619733 . . .6 0,85642564 . . . 0,79705123 . . .

0,77130092 . . .7 0,95274133 . . . 0,74555061 . . .

Table 2.3 Coefficients des termes et sous-produits après réduction de la précision des Ak,j et Bk.

2.3 Architecture

2.3.1 Vue d’ensemble

L’architecture globale d’un opérateur construit selon la méthode HOTBM est donnée figure2.16. La structure de cette architecture découle directement de l’équation 2.1. Ainsi, tous les termesT ′

k sont calculés en parallèle.Les termes de degré non nul sont eux-mêmes évalués en fonction des T ∗

k grâce aux identitésde symétrie paire ou impaire présentées plus haut : le bit de poids fort de B donne le signe deB′

k, et B∗k est déduit de Bk grâce à quelques portes XOR. Comme on sait d’ailleurs que le bit de

poids faible de B∗k est toujours 1, celui-ci reste toujours implicite. Ainsi, le signal B∗

k ne comtientque βk − 1 bits en pratique.La reconstruction s’effectue par la somme ou la différence des T ∗

k , selon la parité de k et lesigne de B′

k (donné par B(−1)).De plus, pour pouvoir assurer l’arrondi fidèle du résutat R = f(X), on effectue les calculs

internes avec une précision supérieure aux wO bits requis : on ajoute pour cela g bits de garde, la

2.3 Architecture 53

−0,002

−0,001

0

−0,08

0

0,08

0

0,5

1

0 1 · 2−3 2 · 2−3 3 · 2−3 4 · 2−3 5 · 2−3 6 · 2−3 7 · 2−3 1

X

T ′

0(A0)

T ′

1(A1, B1)

T ′

2(A2, B2)

I0 I1 I2 I3 I4 I5 I6 I7

Figure 2.15 Représentation des termes T ′0, T

′1 et T

′2 pour la fonction f(x) = log2(1+x). Les courbes

en trait fin sont obtenues lorsque B∗kk est calculé exactement et continûment : elles témoignentuniquement de la valeur des coefficients K ′

k,j(Ak,j). Les points représentent les valeurs effective-ment calculées pour chacun des termes.

valeur de g étant obtenue grâce à une analyse d’erreur présentée dans la suite. Il faut donc enfinarrondir la somme de tous les termes pour se débarrasser de ces bits de garde et obtenir le résultatfinal sur wO bits.Le nombre de bits en sortie des termes T ∗

k dépend de l’ordre de grandeur des valeurs qu’ilspeuvent prendre. Il s’agit cependant toujours de nombres en virgule fixe avec wO + g − k(α + 1)

bits de partie fractionnaire. Ainsi, la somme/différence finale des termes T ∗k pondérés par 2

−k(α+1)

s’effectue sur des nombres de même précision.

2.3.2 Termes tabulés

L’architecture générale d’un terme tabulé T ∗k (Ak, B∗

k) est représentée figure 2.17.


wO + g

wO

R ≈ f (X)

α0

α β

A B

A0

αnβn

Bn

AnB∗n

.. .

α2β2

B2

A2B∗2

B1

α1β1

A1B∗1

wI

B(−1) B(−1) B(−1)

X

Arrondi

˜T ∗0 (A0)

˜T ∗n(An, B

∗n)

˜T ∗2 (A2, B

∗2)

˜T ∗1 (A1, B

∗1)

XOR XORXOR

Figure 2.16 Architecture globale d’un opérateur HOTBM.

A0

α0

˜T ∗0 (A0)

˜K ′0(A0)

αk

Ak B∗k

βk − 1

˜T ∗k (Ak, B

∗k)

˜K ′k(Ak) · B∗k

k

Figure 2.17 Architecture des termes T ∗0 (A0) (à gauche) et T ∗

k (Ak, B∗k) (à droite) implémentés par

de simples tables.

2.3 Architecture 55

La table en question est adressée par les αk bits de Ak et les βk − 1 bits de B∗k (ici non plus on

ne compte pas le 1 implicite de poids faible) lorsque k ≥ 1. Lorsque k = 0, la table n’est adresséeque par les α0 bits de A0, puisque ce terme ne dépend pas de B.

2.3.3 Termes puissance et produit

La figure 2.18 présente l’architecture générale d’un terme T ∗k évalué explicitement par l’éléva-

tion à la puissance k de B∗k et le produit de B∗k

k par Kk(Ak).

B∗k

βk − 1

λk

S∗k,mk

S∗k,2

σk,2

Sk,2

σk,mk

Sk,mk

σk,1 Sk,1

Ak

αk

αk,1

Ak,1

αk,mk

Ak,mk

αk,2

Ak,2

.. .

˜T ∗k (Ak, B

∗k)

Sk,2,(−1) Sk,mk,(−1)

Puissan e k

XOR XOR˜K ′

k,1(Ak,1)˜K ′

k,2(Ak,2) ˜K ′k,mk

(Ak,mk)

· S∗k,mk

Figure 2.18 Architecture du terme T ∗k (Ak, B

∗k) implementé sous forme puissance et produit.

La symétrie étant aussi exploitée pour les sous-produits Qk,j avec j > 1, on retrouve desrangées de portes XOR permettant de calculer chaque S∗

k,j en fonction de Sk,j et du signe de S′k,j,

donné par Sk,j,(−1). On considère de plus que le 1 de poids faible de S∗k,j est implicite.

La reconstruction s’effectue en calculant la somme ou la différence des différents sous-pro-duits, selon leur signe.

Comme précédemment, chacun des sous-produit S∗k,j est calculé comme un nombre en virgule

fixe avec wO + g− k(α+ 1)− ρk,j − 1 bits de partie fractionnaire (ou wO + g− k(α + 1) bits lorsquej = 1), de manière à garantir une même précision lors de la somme finale.



Simple table

Lorsque l’élévation à la puissance k deB∗k est réalisée grâce à une table, celle-ci est directement

adressée par les βk − 1 bits de B∗k (on considère encore une fois son 1 de poids faible comme

implicite). Les valeurs contenues dans la table sont directement arrondies sur λk bits.

Somme de produits partiels

L’opérateur dédié calculant explicitement la somme des produits partiels de B∗kk est présenté

figure 2.19.

λk

Sk

B∗k

βk − 1

µk

Produits partiels

Tron ature

Figure 2.19 Architecture d’un opérateur d’élévation à la puissance k par somme des produitspartiels.

Comme expliqué précédemment, seuls les produits partiels de poids supérieur à 2−µk sontpris en compte. Ils sont générés grâce à de simples portes ET. Un arbre d’additionneurs effectueensuite leur somme, toujours sur µk bits. Enfin, le résultat est tronqué à ses λk bits de poids fort.

2.4 Analyse d’erreur

Cette partie détaille les différentes erreurs entrant en jeu dans la conception d’un opérateurselon laméthodeHOTBM.Comme l’opérateur travaille en virgule fixe, ces erreurs sont des erreursabsolues et non relatives.Tenir précisément compte de l’influence de toutes ces erreurs permet alors de garantir l’arrondi

fidèle du résultat, soit :ǫabsf = max

X∈I

∣∣∣f(X) − f(X)∣∣∣ < ǫmax

f ≤ 2−wO ,

avec la contrainte ǫmaxf > 2−wO−1 du fait du dilemme du fabriquant de tables.

Pour plus de précision dans cette analyse d’erreur, la méthode HOTBM n’encadre pas cha-cune de ses erreurs par des constantes mais par des polynômes par morceaux. L’erreur est ainsibien mieux maîtrisée et bornée plus finement. Il s’agit ici d’une des grandes originalités de notreméthode.

2.4 Analyse d’erreur 57

2.4.1 Approximation polynômiale : ǫpoly

L’approximation de la fonction f par un polynôme Pi sur chaque sous-intervalle Ii engendreune erreur notée ǫpoly définie comme suit :

ǫpoly(X) = f(X) − P (A, 2−αB).

L’algorithme de Remez utilisé pour calculer ces polynômes Pi nous donne pour cela ǫabspoly,Pi

, lavaleur maximale de l’erreur absolue commise pour chacun des sous-intervalles Ii :

ǫabspoly,Pi

= maxX∈Ii

∣∣f(X) − Pi(2−αB)

∣∣ .

De plus, l’algorithme de Remez garantit que l’erreur du polynômeminimax obtenu est centréeautour de 0 :

maxX∈Ii

f(X) − Pi(2−αB) = ǫabs

poly,Pi, et

minX∈Ii

f(X) − Pi(2−αB) = − ǫabs

poly,Pi.

On obtient ainsi les bornes suivantes pour ǫpoly :

−ǫabspoly,PA

≤ ǫpoly(X) ≤ ǫabspoly,PA

.

Il est intéressant de noter qu’exploiter la symétrie paire ou impaire de chacun des termes despolynômes ainsi obtenus n’engendre aucune erreur additionnelle, puisqu’on a l’égalité suivante :

P (A, 2−αB) =

n∑

k=0

Tk(A,B) =

n∑

k=0

T ′k(A,B).

Exemple 2.11 Dans le cadre de notre exemple pour la fonction f(x) = log2(1+x), la liste desǫabspoly,PA

en fonction deA est donnée table 2.4. L’erreur ǫpoly(X) commise par l’approximationminimax est représentée figure 2.20.

A ǫabspoly,PA

0 2,24357839 . . . · 10−5

1 1,60517441 . . . · 10−5

2 1,18778302 . . . · 10−5

3 0,90345166 . . . · 10−5

4 0,70310574 . . . · 10−5

5 0,55788585 . . . · 10−5

6 0,45006157 . . . · 10−5

7 0,36832918 . . . · 10−5

Table 2.4 Borne de l’erreur absolue ǫabspoly,PA

engendrée par l’approximation de f(x) = log2(1 + x)par un polynôme minimax sur l’intervalle IA.


−2 · 10−5

0

2 · 10−5

0 1 · 2−3 2 · 2−3 3 · 2−3 4 · 2−3 5 · 2−3 6 · 2−3 7 · 2−3 1

X

ǫpoly(X)I0 I1 I2 I3 I4 I5 I6 I7

Figure 2.20 Représentation de l’erreur d’approximation ǫpoly(X) de la fonction f(x) = log2(1+x).L’erreur effective est représentée en traits fins et son encadrement par±ǫabs

poly,PAen traits normaux.

2.4.2 Adaptation de la précision : ǫmethod

Moins de bits pour A : ǫmethod,Ak

Diminuer à αk le nombre de bits de A utilisés pour calculer le coefficient K ′(A) du termed’ordre k engendre une erreur notée ǫmethod,Ak

:

ǫmethod,Ak(X) = T ′

k(A,B) − T ′k(Ak, B)

=(K ′

k(A) − K ′k(Ak)

)· B′k · 2−kα.

Ainsi, ici, nous avons directement l’expression de l’erreur, et non pas un simple encadrement.De plus, la valeur de K ′

k(Ak) explicitée précédemment est choisie de telle sorte que l’erreur com-mise sur le coefficient K ′

k(Ak) soit centrée autour de 0. On a en effet :

K ′k(Ak) =

1

2

(min

0≤C≤2α−αk−1K ′

k

(AkC

)+ max

0≤C≤2α−αk−1K ′

k

(AkC

)),

ce qui donne ainsi :

−1

2

∣∣∣∆ eK ′

k

(Ak)∣∣∣ ≤ K ′

k(A) − K ′k(Ak) ≤

1

2

∣∣∣∆ eK ′

k

(Ak)∣∣∣ ,

avec :∆ eK ′

k(Ak) = max

0≤C≤2α−αk−1K ′

k

(AkC

)− min

0≤C≤2α−αk−1K ′

k

(AkC

).

Exemple 2.12 Pour notre exemple, on a α2 = 1 bit, ce qui entraîne une erreur sur le coef-ficient K ′

2. Cette erreur est donnée en fonction de A dans la table 2.5 et représentée figure2.21.


A A2 K ′2(A) − K ′

2(A2)

0

0

−0,14611052 . . .1 −0,01752854 . . .2 0,07598223 . . .3 0,14611052 . . .

4

1

−0,05190898 . . .5 −0,00953106 . . .6 0,02436823 . . .7 0,05190898 . . .

Table 2.5 Erreur sur les coefficients d’ordre 2 de la fonction f(x) = log2(1 + x) pour α2 = 1 bit.

−6 · 10−4

0

6 · 10−4

0 1 · 2−3 2 · 2−3 3 · 2−3 4 · 2−3 5 · 2−3 6 · 2−3 7 · 2−3 1

X

ǫmethod,A2(X)

I0 I1 I2 I3 I4 I5 I6 I7

Figure 2.21 Représentation de l’erreur ǫmethod,A2(X) commise sur le terme T ′2 avec α2 = 1 bit.

Moins de bits pour B : ǫmethod,Bk

On note ǫmethod,Bkl’erreur commise en ne tenant compte que des βk bits de poids fort de B

lors de l’évaluation d’un terme T ′k. On a alors :

ǫmethod,Bk(X) = T ′

k(Ak, B) − T ′k(Ak, Bk)

= K ′k(Ak) ·

(B′k − B′k

k

)· 2−kα.

On note de plus ǫBk= B − Bk l’erreur commise en tronquant B à ses βk bits de poids fort :

0 ≤ ǫBk≤ 2−βk − 2−β .

Par définition on a B′ = B − ∆ ainsi que B′k = Bk − ∆k, ce qui donne l’expression de B′

k enfonction de B′ :

B′k = B − ǫBk

− ∆k

= B′ + (∆ − ∆k) − ǫBk.

On définit alors ǫB′

k= ǫBk

− (∆ −∆k), ce qui donne B′k = B′ − ǫB′

k. En définissant de plus ǫ+

B′

k

et ǫ−B′

kde la manière suivante :

ǫ+B′

k

= −ǫ−B′

k

=1

2

(2−βk − 2−β

),


on obtient :ǫ−B′

k≤ ǫB′

k≤ ǫ+

B′

k.

L’erreur sur le terme se réécrit alors en :

ǫmethod,Bk(X) = K ′

k(Ak) ·(B′k − (B′ − ǫB′

k)k)· 2−kα.

On obtient ainsi une expression de l’erreur commise sur le terme T ′k sous forme d’un polynôme

de degré k − 1 en B′, et fonction de l’erreur sur Bk. Connaissant les valeurs extrémales de ǫB′

k, on

peut alors vérifier que l’erreur ǫmethod,Bk(X) est toujours comprise entre les polynômes d’erreur

ǫ+method,Bk

(X) et ǫ−method,Bk(X) définis comme suit :

ǫ+method,Bk

(X) = K ′k(Ak) ·

(B′k −

(B′ − ǫ+

B′

k

)k)· 2−kα, et

ǫ−method,Bk(X) = K ′

k(Ak) ·(

B′k −(B′ − ǫ−

B′

k

)k)· 2−kα.

On suppose ici sans perte de généralité que K ′k est positif. Dans le cas contraire, tous les enca-

drements présentés dans la suite doivent être inversés.Ainsi, lorsque k est impair, on a toujours :

(B′ − ǫ+

B′

k

)k

≤(B′ − ǫB′

k

)k

≤(B′ − ǫ−

B′

k

)k

,

ce qui nous donne l’encadrement suivant :

ǫ−method,Bk(X) ≤ ǫmethod,Bk

(X) ≤ ǫ+method,Bk

(X).

De même, si k est pair :– Lorsque 0 ≤ B′ − ǫ+

B′

k≤ B′ − ǫB′

k, on a :

(B′ − ǫ+

B′

k

)k

≤(B′ − ǫB′

k

)k

.

On en déduit alors ǫmethod,Bk(X) ≤ ǫ+

method,Bk(X).

– De la même façon, quand B′ − ǫ+B′

k

≤ B′ − ǫB′

k≤ 0, on a :

(B′ − ǫB′

k

)k

≤(B′ − ǫ+

B′

k

)k

,

ce qui donne ǫ+method,Bk

(X) ≤ ǫmethod,Bk(X).

– Enfin, si B′ − ǫ+B′

k≤ 0 ≤ B′ − ǫB′

k, on cherche à calculer le signe de la différence :

∣∣∣B′ − ǫB′

k

∣∣∣−∣∣∣B′ − ǫ+

B′

k

∣∣∣ =(B′ − ǫB′

k

)+(B′ − ǫ+

B′

k

)

= 2B′ −(ǫ+B′

k+ ǫB′

k

)

≥ 2(B′ − ǫ+

B′

k

).

Or on a B′k = B′ − ǫB′

k≥ 0. Comme le plus petit B′

k positif est 2−βk−1 et que ǫ+

B′

k

< 2−βk−1,on a bien : ∣∣∣B′ − ǫ+

B′

k

∣∣∣ ≤∣∣∣B′ − ǫB′

k

∣∣∣ ,


ce qui donne : (B′ − ǫ+

B′

k

)k

≤(B′ − ǫB′

k

)k

,

soit finalement ǫmethod,Bk(X) ≤ ǫ+

method,Bk(X).

En appliquant le même raisonnement pour ǫ−B′

ket ǫ−method,Bk

(X), on peut démontrer les inéga-lités symétriques symétriques, ce qui nous donne enfin l’encadrement de ǫmethod,Bk

(X) lorsque kest pair : {

ǫ+method,Bk

(X) ≤ ǫmethod,Bk(X) ≤ ǫ−method,Bk

(X) quand B′ ≤ 0, et

ǫ−method,Bk(X) ≤ ǫmethod,Bk

(X) ≤ ǫ+method,Bk

(X) quand B′ ≥ 0.

La figure 2.22 présente l’erreur obtenue pour des termes de degré k = 1, 2 et 3, avec β = 8 bitset βk = 5, 4 et 3 bits respectivement. Pour plus de clarté, l’erreur n’est représentée que sur un seulintervalle Ii.On peut cependant remarquer que la fonction ǫ+

method,Bk(X) peut borner bien plus précisément

à la courbe d’erreur effective sur l’intervalle B′ ∈[−∆,−∆ + 2−βk

[, qui correspond à B′

k = −∆k.Il en va de même pour la fonction ǫ−method,Bk

(X) sur l’intervalle symétrique B′ ∈]∆ − 2−βk ,∆

],

soit B′k = ∆k.

On définit alors ces deux fonctions comme des polynômes par morceaux, en utilisant pour cesintervalles la valeur effective de l’erreur commise ǫmethod,Bk

(X). On a ainsi :

ǫ+method,Bk

(X) =

K ′k(Ak) ·

(B′k − (−∆k)

k)· 2−kα pour B′ ∈

[−∆,−∆ + 2−βk

[,

K ′k(Ak) ·

(B′k −

(B′ − ǫ+

B′

k

)k)· 2−kα pour B′ ∈

[−∆ + 2−βk ,∆

],

ǫ−method,Bk(X) =

K ′k(Ak) ·

(B′k −

(B′ − ǫ−

B′

k

)k)· 2−kα pour B′ ∈

[−∆,∆ − 2−βk

], et

K ′k(Ak) ·

(B′k − ∆k

k

)· 2−kα pour B′ ∈

]∆ − 2−βk ,∆

].

Les fonctions ainsi construites sont représentées figure 2.23, pour les mêmes paramètres queprécédemment. On peut constater cette fois-ci que l’encadrement de l’erreur est plus précis sur lesdeux intervalles considérés.Enfin, dans les cas où βk n’est pas trop grand, on peut se passer de l’encadrement pour plutôt

considérer directement l’erreur effectivement commise ǫmethod,Bk(X). Cette erreur est en effet un

polynôme par morceaux, chaque morceau correspondant à une même valeur de B′k = B′ − ǫB′

k:


k(Ak) ·(B′k − B′k

k

)· 2−kα, pour B′ ∈

[B′

k + ǫ−B′

k, B′

k + ǫ+B′

k

].

Exemple 2.13 Dans l’exemple de la fonction f(x) = log2(1 + x), on prend pour le termed’ordre quadratique T ′

2 uniquement β2 = 4 bits. L’erreur ainsi commise est représentéefigure 2.24.

Amélioration de ǫmethod,Bkpour les termes tabulés

Il est possible d’affiner le centrage autour de zéro de l’erreur ǫmethod,Bk(X) commise sur les

termes tabulés. En effet, utiliser uniquement les βk bits de poids fort de B revient à partager une


0

0

0

i · 2−α ∆ (i + 1) · 2−α

X

ǫmethod,B1(X)

ǫmethod,B2(X)

ǫmethod,B3(X)

Ii

Figure 2.22 Erreurs commises sur des termes d’ordre 1, 2 et 3 pour différentes valeurs de βk < β,sur le sous-intervalle Ii. Ici, β = 8 bits, et β1, β2 et β3 valent 5, 4 et 3 bits respectivement. L’erreureffective ǫmethod,Bk

(X) est représentée en traits fins. Les bornes ǫ+method,Bk

(X) et ǫ−method,Bk(X) sont

représentées en traits normaux, avec des points noirs et blancs respectivement.

même valeur du terme T ∗k (Ak, B

∗) sur l’intervalle des B∗ qui se ramènent à un même B∗k une fois

tronqués, soit B∗ ∈[B∗

k + ǫ−B∗

k, B∗

k + ǫ+B∗

k

], avec :

ǫ+B∗

k= max (B∗ − B∗

k) = 2ǫ+B′

k, et

ǫ−B∗

k= min (B∗ − B∗

k) = 2ǫ−B′

k.

Plutôt que de tabuler directement T ∗k (Ak, B

∗k) = K ′

k(Ak) · B∗kk , on choisit donc de stocker dans

la table la moyenne des valeurs extrémales du terme T ∗k (Ak, B

∗) pour B∗ ∈[B∗

k + ǫ−B∗

k, B∗

k + ǫ+B∗

k

],

soit la valeur :

T ∗k (Ak, B

∗k) = K ′

k(Ak) ·1

2

((B∗

k + ǫ−B∗

k

)k

+(B∗

k + ǫ+B∗

k

)k),


0

0

0

i · 2−α ∆ (i + 1) · 2−α

X

ǫmethod,B1(X)

ǫmethod,B2(X)

ǫmethod,B3(X)

Ii

Figure 2.23 Amélioration de l’encadrement des erreurs de la figure 2.22.

ce qui donne alors, comme ǫ−B∗

k= −ǫ+

B∗

k:

T ′k(Ak, Bk) = K ′

k(Ak) ·1

2

((2B′

k + 2ǫ−B′

k

)k

+(2B′

k + 2ǫ+B′

k

)k)· 2−k(α+1)

= K ′k(Ak) ·

1

2

((B′

k + ǫ−B′

k

)k

+(

B′k + ǫ+

B′

k

)k)· 2−kα.

L’erreur commise devient ainsi :


k(Ak) ·[B′k − 1

2

((B′

k + ǫ−B′

k

)k

+(B′

k + ǫ+B′

k

)k)]

· 2−kα.

On peut alors calculer comme précédemment l’encadrement de cette erreur par des polynômespar morceaux et ainsi vérifier que l’erreur ǫmethod,Bk

(X) est bien centrée autour de zéro.L’exemple des erreurs commises sur les termes T ′

1, T′2 et T

′3 est repris figure 2.25 dans le cas où

ces trois termes sont tabulés.


−10−4

0

10−4

0 1 · 2−3 2 · 2−3 3 · 2−3 4 · 2−3 5 · 2−3 6 · 2−3 7 · 2−3 1

X

ǫmethod,B2(X)

I0 I1 I2 I3 I4 I5 I6 I7

Figure 2.24 Erreur ǫmethod,B2(X) commise sur le terme T ′2 pour l’exemple f(x) = log2(1 + x). Les

bornes ǫ+method,B2

(X) et ǫ−method,B2(X) sont représentées en traits normaux, et l’erreur exacte en

traits fins.

Combinaison de ǫmethod,Aket ǫmethod,Bk

Nous définissons ǫmethod,Ak,Bk(X) comme l’erreur totale commise sur le terme T ′

k calculé avecles αk bits de Ak et les βk bits de Bk. On a ainsi :

ǫmethod,Ak,Bk(X) = T ′

k(A,B) − T ′k(Ak, Bk) = ǫmethod,Ak

(X) + ǫmethod,Bk(X).

D’après les encadrements vus précédemment pour ces deux erreurs, on peut donc écrire :

ǫmethod,Ak(X) + ǫmin

method,Bk(X) ≤ ǫmethod,Ak,Bk

(X) ≤ ǫmethod,Ak(X) + ǫmax

method,Bk(X),

avec :

ǫminmethod,Bk

(X) = min(ǫ−method,Bk

(X), ǫ+method,Bk

(X)), et

ǫmaxmethod,Bk

(X) = max(ǫ−method,Bk

(X), ǫ+method,Bk

(X)).

L’encadrement de l’erreur ǫmethod,Ak,Bk(X) peut donc encore une fois être exprimé sous la

forme d’un couple de polynômes par morceaux.

Exemple 2.14 Considérant toujours le terme d’ordre 2 de notre exemple, la figure 2.26 pré-sente l’erreur ǫmethod,A2,B2(X) ainsi que son encadrement par des polynômes par morceaux.

Élévation à la puissance : ǫmethod,Sk

Que le calcul de B∗kk soit par des valeurs tabulées ou bien évalué par une somme de produits

partiels, il est difficile d’encadrer avec précision l’erreur commise par l’opérateur d’élévation àla puissance par des polynômes par morceaux. Nous devons donc nous contenter pour cela debornes constantes l’ensemble de l’intervalle I .


0

0

0

i · 2−α ∆ (i + 1) · 2−α

X

ǫmethod,B1(X)

ǫmethod,B2(X)

ǫmethod,B3(X)

Ii

Figure 2.25 Erreurs commises sur les termes tabulés T ′1, T

′2 et T

′3. Même si cela est difficilement

remarquable à l’œil nu, ces erreurs sont correctement centrées autour de zéro, contrairement auxerreurs de la figure 2.23.

Ainsi, comme on l’avait déjà vu dans le cas d’une table simple, l’erreur ǫSkcommise sur Sk

vérifie :

|ǫSk| ≤ 2−λk−1 − 2−kβk .

De même, il est aussi possible de borner simplement l’erreur ǫSklorsque celle-ci est engendrée

par un opérateur dédié un fois connu le tableau des produits partiels.L’erreur ainsi commise est ensuite étendue à l’intervalle complet couvert par B′

k. Cela revientà appliquer une symétrie paire ou impaire selon si k est pair ou impair, respectivement. Enfin,l’erreur est multipliée par la valeur du coefficient K ′

k(Ak) sur chacun des sous-intervalles IA puispar 2−k(α+1), l’ordre de grandeur du terme.L’erreur finalement obtenue est notée ǫmethod,Sk

(X), et son encadrement peut aussi être aisé-ment déduit des bornes calculées sur ǫSk

.


−6 · 10−4

0

6 · 10−4

0 1 · 2−3 2 · 2−3 3 · 2−3 4 · 2−3 5 · 2−3 6 · 2−3 7 · 2−3 1

X

ǫmethod,A2,B2(X)

I0 I1 I2 I3 I4 I5 I6 I7

Figure 2.26 Erreur ǫmethod,A2,B2(X) commise sur le terme T ′2 pour l’exemple f(x) = log2(1 + x).

Les majorant et minorant de cette erreur sont représentés avec des points noirs et blancs respecti-vement.

Exemple 2.15 On considère ici l’erreur ǫmethod,S2(X) commise pour le terme quadratiquede l’exemple f(x) = log2(1 + x), pour µ2 = 3 et λ2 = 2 bits.On avait déjà construit le tableau de produits partiels de manière à avoir :

2−8 − 2−2 = −63 · 2−8 ≤ ǫS2 ≤ 2−3 + 2−8 = 33 · 2−8.

En fait, comme β2 n’est que de 4 bits, on peut réaliser une analyse d’erreur exhaustive pourS2, ce qui donne alors l’encadrement plus fin suivant :

−39 · 2−8 ≤ ǫS2 ≤ 17 · 2−8.

Sachant que le coefficient K ′2 est toujours négatif, cela nous donne alors les bornes suivantes

pour l’erreur ǫmethod,S2(X) :

K ′2(A2) ·

(17 · 2−8

)· 2−2(α+1) ≤ ǫmethod,S2(X) ≤ K ′

2(A2) ·(−39 · 2−8

)· 2−2(α+1),

soit plus simplement :

17 · K ′2(A2) · 2−16 ≤ ǫmethod,S2(X) ≤ −39 · K ′

2(A2) · 2−16.

Cette erreur et son encadrement sont représentés figure 2.27.

Moins de bits pour Ak : ǫmethod,Ak,j

On se place ici dans le cas 1 < j ≤ mk. En effet, lorsque j = 1, comme Ak,1 = Ak par définition,aucune erreur additionnelle n’est commise sur le sous-produit Qk,1(Ak,1, Sk,1).Par contre, pour j > 1, le calcul de chacun des sous-produits Qk,j(Ak,j, Sk,j) en utilisant uni-


−10−4

0

3 · 10−4

0 1 · 2−3 2 · 2−3 3 · 2−3 4 · 2−3 5 · 2−3 6 · 2−3 7 · 2−3 1

X

ǫmethod,S2(X)

I0 I1 I2 I3 I4 I5 I6 I7

Figure 2.27 Erreur ǫmethod,S2(X) commise sur le terme T ′2 pour l’exemple f(x) = log2(1 + x). Les

bornes supérieure et inférieure sont représentées avec des points noirs et blancs respectivement.

quement les αk,j bits de poids fort de Ak génère bien une erreur, notée ǫmethod,Ak,j(X). Dans le cas

où k est impair (le cas pair se déduisant en ignorant simplement le changement de signe dû à lasymétrie), on a ainsi :

ǫmethod,Ak,j(X) = (−1)¬Bk,(−1) ·

(Qk,j(Ak, Sk,j) − Qk,j(Ak,j, Sk,j)

)· 2−k(α+1)

= (−1)¬Bk,(−1) ·(K ′

k(Ak) − K ′k,j(Ak,j)

)· S′

k,j · 2−k(α+1)−ρk,j−1.

Comme on a −∆k,j ≤ S′k,j ≤ ∆k,j, on obtient l’encadrement suivant :

−∣∣∣K ′


∣∣∣ · ∆k,j · 2−k(α+1)−ρk,j−1 ≤ ǫmethod,Ak,j(X)

≤∣∣∣K ′


∣∣∣ · ∆k,j · 2−k(α+1)−ρk,j−1.

De plus, les valeurs des coefficients K ′k,j(Ak,j) ont justement été choisies de sorte à centrer

autour de zéro l’erreur commise sur ces coefficients :

−1

2

∣∣∣∆ eK ′

k,j(Ak,j)

∣∣∣ ≤ K ′k(Ak) − K ′

k,j(Ak,j) ≤1

2

∣∣∣∆ eK ′

k,j(Ak,j)

∣∣∣ ,

avec :∆ eK ′

k,j(Ak,j) = max


K ′k

(Ak,jC

)− min


K ′k

(Ak,jC

).

Exemple 2.16 Le calcul du terme T ′1 de notre exemple est réparti sur deux sous-produits,

avec α1 = α = 5 bits. Cependant, le moins significatif de ces sous-produits est évalué avecα1,2 = 4 bits seulement. L’erreur ainsi commise sur le coefficient K ′

1,2(A1,2) est donnée dansla table 2.6. L’erreur générée au niveau du terme T ′

1 est quant à elle représentée figure 2.28.


A1 A1,2 K ′1(A1) − K ′

1,2(A1,2)

00

0,07187219 . . .1 −0,07187219 . . .

21

0,04799783 . . .3 −0,04799783 . . .

42

0,03431564 . . .5 −0,03431564 . . .

63

0,02575031 . . .7 −0,02575031 . . .

Table 2.6 Erreur sur les coefficients du sous-produit Q1,2 pour la fonction f(x) = log2(1 + x), avecα1,2 = 2 bits.

−10−3

0

10−3

0 1 · 2−3 2 · 2−3 3 · 2−3 4 · 2−3 5 · 2−3 6 · 2−3 7 · 2−3 1

X

ǫmethod,A1,2(X)

I0 I1 I2 I3 I4 I5 I6 I7

Figure 2.28 Erreur ǫmethod,A1,2(X) commise sur le sous-produit Q1,2 pour l’exemple f(x) =log2(1 + x). Les bornes supérieure et inférieure sont représentées avec des points noirs et blancsrespectivement.

Erreur totale : ǫmethod

L’erreur de méthode totale est enfin obtenue en sommant toutes les erreurs présentées précé-demment :

ǫmethod(X) = ǫmethod,A0(X) +

n∑

k=1

ǫmethod,Ak,Bk

(X) + ǫmethod,Sk(X) +

mk∑

j=2

ǫmethod,Ak,j(X)

.

Comme toutes ces erreurs sont bornées grâce à des polynômes par morceaux, leur sommeǫmethod(X) peut être à son tour encadrée précisément par la somme des bornes inférieures et su-périeures des différentes erreurs.

Exemple 2.17 L’erreur de méthode commise par l’implémentation choisie de la fonctionf(x) = log2(1 + x) est donnée figure 2.29.


L’expression de cette erreur est donnée par :

ǫmethod(X) = ǫmethod,A1,2(X) + ǫmethod,A2,B2(X) + ǫmethod,S2(X).

−10−3

0

10−3

0 1 · 2−3 2 · 2−3 3 · 2−3 4 · 2−3 5 · 2−3 6 · 2−3 7 · 2−3 1

X

ǫmethod(X)I0 I1 I2 I3 I4 I5 I6 I7

Figure 2.29 Erreur de méthode totale ǫmethod(X) commise par l’opérateur HOTBM sur l’exemplef(x) = log2(1 + x). Les bornes supérieure et inférieure sont représentées avec des points noirs etblancs respectivement.

Correction de l’erreur absolue de méthode

Une fois les bornes sur l’erreur de méthode connues, on peut corriger celle-ci en la centrantautour de zéro, de manière à minimiser sa valeur absolue maximale.Les bornes étant données par des polynômes par morceaux, notés ǫ−method(X) et ǫ+

method(X)pour le minorant et le majorant respectivement, cela revient à calculer les extrema de ces po-lynômes sur chacun des sous-intervalles IA, puis de corriger la valeur du coefficient d’ordre 0

K ′0(A) pour ce sous-intervalle.La valeur de cette correction C(A) est donnée par l’expression :

C(A) =1

2

(maxX∈IA

ǫ+method(X) + min

X∈IA

ǫ−method(X)

).

Exemple 2.18 L’erreur de méthode commise par l’implémentation choisie de la fonctionf(x) = log2(1 + x) est donnée figure 2.30.

2.4.3 Erreurs d’arrondis

Arrondis des tables et des multiplieurs : ǫround

Comme cela a déjà été mentionné, toutes les valeurs contenues dans les tables sont arrondiesde telle sorte que l’erreur d’arrondi ainsi commise, une fois propagée jusqu’à l’additionneur final,soit bornée par 2−wO−g−1, soit 1

2 ulp de la précision interne.


A maxX∈IAǫ+method(X) minX∈IA

ǫ−method(X) C(A)

0 7,95040084 . . . · 10−4 −12,71286174 . . . · 10−4 −2,38123045 . . . · 10−4

1 8,42316594 . . . · 10−4 − 7,99914387 . . . · 10−4 0,21201104 . . . · 10−4

2 9,79110539 . . . · 10−4 − 4,67331813 . . . · 10−4 2,55889363 . . . · 10−4

3 12,04093335 . . . · 10−4 − 4,61365108 . . . · 10−4 3,71364114 . . . · 10−4

4 3,85436069 . . . · 10−4 − 5,45227786 . . . · 10−4 −0,79895859 . . . · 10−4

5 4,04981716 . . . · 10−4 − 3,89873545 . . . · 10−4 0,07554086 . . . · 10−4

6 4,54794507 . . . · 10−4 − 2,47814518 . . . · 10−4 1,03489995 . . . · 10−4

7 5,43149639 . . . · 10−4 − 2,42916232 . . . · 10−4 1,50116704 . . . · 10−4

Table 2.7 Extrema et correctif C(A) de l’erreur de méthode ǫmethod(X) pour la fonction f(x) =log2(1 + x).

−10−3

0

10−3

0 1 · 2−3 2 · 2−3 3 · 2−3 4 · 2−3 5 · 2−3 6 · 2−3 7 · 2−3 1

X

ǫmethod(X)I0 I1 I2 I3 I4 I5 I6 I7

Figure 2.30 Erreur de méthode ǫmethod(X) pour la fonction f(x) = log2(1 + x) recentrée autour dezéro grâce au terme correctif C(A).

Ainsi, pour un terme T ′k directement tabulé, les valeurs stockées dans la table T ∗

k seront arron-dies à wO + g − k(α + 1) bits de partie fractionnaire, car elles sont ensuite multipliées par 2−k(α+1)

avant l’addition finale.De même, pour un sous-produit Qk,j impliqué dans le calcul du terme d’ordre k, la table,

qu’elle stocke les valeurs de K ′k,j(Ak,j) ou bien directement le produit K ′

k,j(Ak,j) · S∗k,j , sera arron-

die à wO + g − k(α + 1) − ρk,j − 1 bits de partie fractionnaire. En effet, son résultat est ensuitemultiplié par 2−ρk,j−1 puis par 2−k(α+1) avant l’addition finale.Enfin, pour chaque sous-produit Qk,j calculé grâce à un véritable multiplieur, il faut aussi

arrondir le résultat de ce multiplieur à wO + g − k(α + 1) − ρk,j − 1 bits de partie fractionnaire.Cela est fait en tronquant le résultat et en rajoutant un 1

2 ulp à la somme finale pour corriger.Cependant, du fait de la symétrie, il faut parfois soustraire la valeur d’un sous-produit et non

l’additionner dans la somme finale. Cela demande donc de calculer l’opposé de la valeur tronquéeà wO +g−k(α+1)−ρk,j −1 bits de partie fractionnaire, en inversant tous ses bits et en y rajoutant1 ulp, puis de soustraire aussi le 1

2 ulp correcteur. En simplifiant ces calculs, l’opposé est alorssimplement obtenu en inversant tous les bits du sous-produit et en rajoutant le même 1

2 ulp.Cette astuce due à Schulte et Stine [SS97] permet ainsi de simplifier le calcul de l’opposé d’un


sous-produit pour les éventuelles soustractions finales en considérant comme implicite le 12 ulp

correcteur. Ce calcul de l’opposé est alors réalisé à l’aide uniquement de quelques portes XOR,contrôlées par les bits de signe Sk,j,(−1) et B(−1).En notant nT le nombre de tables (qu’elles stockent des coefficients, des sous-produits ou bien

des termes complets) et nM le nombre de multiplieurs de l’opérateur HOTBM, on a ainsi :

|ǫround(X)| ≤ (nT + nM) · 2−wO−g−1.

Exemple 2.19 Pour notre exemple, le terme T ′0 est ainsi tabulé avec w0 + g = 8 + g bits de

partie fractionnaire.De même, pour le terme T ′

1, le sous-produit Q1,1 est calculé avec w0 +g− (α+1) = 4+g bitsde partie fractionnaire, tant pour la table stockant les valeurs du coefficient K ′

1,1(A1,1) quepour le produit de ce coefficient par S∗

1,1. Le sous-produit Q1,2, quant à lui, est directementtabulé avec wO + g − (α + 1) − ρ1,2 − 1 = 2 + g bits de précision.Enfin, l’unique sous-produit Q2,1 du terme quadratique, lui aussi directement tabulé, estarrondi à wO + g − 2(α + 1) = g bits de partie fractionnaire.L’erreur totale due à ces nT + nM = 4 + 1 = 5 arrondis est alors bornée par :

|ǫround(X)| ≤ 5 · 2−wO−g−1 = 5 · 2−9−g .

La figure 2.31 présente cette erreur ainsi que son encadrement, pour g = 4 bits de garde. Onpeut remarquer ici que l’encadrement sur l’erreur d’arrondi est bien moins fin que celui del’erreur de méthode. Cela est dû au fait que le comportement des erreurs d’arrondis est bienplus difficile à maîtriser et à prévoir que ne l’est l’erreur de méthode.

−5 · 10−4

0

5 · 10−4

0 1 · 2−3 2 · 2−3 3 · 2−3 4 · 2−3 5 · 2−3 6 · 2−3 7 · 2−3 1

X

ǫround(X)I0 I1 I2 I3 I4 I5 I6 I7

Figure 2.31 Erreurs d’arrondis ǫround(X) commises pour g = 4 bits de garde sur l’exemple f(x) =log2(1 + x). Les bornes supérieure et inférieure sont représentées avec des points noirs et blancsrespectivement.


Arrondi final : ǫfinal

Au niveau de la somme finale, la précision de chacun des termes est ainsi fixée à wO + g bitsde partie fractionnaire. Cependant, le résultat de l’opérateur doit être arrondi à wO bits de partiefractionnaire, ce qui entraîne une erreur supplémentaire notée ǫfinal.A priori, cette erreur est bornée en valeur absolue par 2−wO−1. Cependant, une astuce de Das

Sarma et Matula [DSM95] permet de réduire cette borne à 2−wO−1 · (1− 2−g). Il suffit en effet pourcela de considérer que la somme finale comporte un 1 implicite de poids 2−w0−g−1, dû à l’un des12 ulp rajouté pour l’arrondi en sortie des multiplieurs ou bien porté directement par le terme T ′

0.

Exemple 2.20 Dans notre exemple, un seul sous-produit est calculé à l’aide d’un vrai multi-plieur. L’arrondi du résultat de ce multiplieur entraîne l’apparition d’un 1

2 ulp implicite quiest propagé jusqu’à la somme finale.L’arrondi au plus proche de cette somme à wO bits de partie fractionnaire génère alors uneerreur ǫfinal bornée par :

|ǫfinal(X)| ≤ 2−wO−1 · (1 − 2−g) = 2−9 · (1 − 2−g).

2.4.4 Combinaison de toutes les erreurs

L’erreur totale ǫf commise entre la fonction originale f et la fonction f calculée par l’opérateurHOTBM correspond à la somme de toutes les erreurs présentées plus haut. Ainsi :

ǫf (X) = f(X) − f(X) = ǫpoly(X) + ǫmethod(X) + ǫround(X) + ǫfinal(X).

Ayant aussi encadré précisément chacune de ces erreurs, on peut alors faire de même pour ǫf :

|ǫf (X)| ≤ maxX∈I

|ǫpoly(X)|︸︷︷︸

+ maxX∈I

|ǫmethod(X)|︸︷︷︸

+ maxX∈I

|ǫround(X)|︸︷︷︸

+ maxX∈I

|ǫfinal(X)|︸︷︷︸

≤ max0≤A≤2α−1

ǫabspoly,PA

+ maxX∈I

|ǫmethod(X)| + (nT + nM) · 2−wO−g−1 + 2−wO−1 · (1 − 2−g)

= max0≤A≤2α−1

ǫabspoly,PA

+ maxX∈I

|ǫmethod(X)| + (nT + nM − 1) · 2−wO−g−1 + 2−wO−1.

Pour satisfaire la borne d’erreur ǫmaxf souhaitée, on a de plus la contrainte suivante :

|ǫf (X)| < ǫmaxf , pour toutX ∈ I .

Cette contrainte, appliquée à la borne sur |ǫf (X)| calculée plus haut, nous permet ainsi decalculer une borne inférieure pour le nombre g de bits de garde :

g > −wO − 1 − log2

ǫmaxf − 2−wO−1 − max

0≤A≤2α−1ǫabspoly,PA

− maxX∈I

|ǫmethod(X)|

nT + nM − 1

.

Enfin, comme nous avons calculé à chaque fois la somme des erreursmaximales, l’erreur totalea pu être surestimée et moins de bits de garde pourraient suffire. Lorsque la taille de l’entrée wI

n’est pas trop importante, on peut alors réaliser un simple test exhaustif pour trouver le plus petitg possible. Cela nous permet parfois de gagner jusqu’à deux bits de garde.

2.5 Résultats 73

Exemple 2.21 Dans le cadre de notre exemple pour la fonction f(x) = log2(1 + x), on a :

ǫabspoly,PA

≤ 2,24357839 . . . · 10−5, et

|ǫmethod(X)| ≤ 1,03316313 . . . · 10−3,

ce qui donne, avec ǫmaxf = 2−wO :

g > −wO − 1 − log2

(2−wO − 2−wO−1 − 2,24357839 . . . · 10−5 − 1,03316313 . . . · 10−3

nT + nM − 1

)

≈ 3,12175851 . . . .

Il faut donc prendre g = 4 bits de garde pour assurer l’arrondi fidèle du résultat.

2.5 Résultats

Cette section présente des estimations de surface et de délai de divers opérateurs HOTBMaprès placement et routage. Ces estimations ont été obtenues grâce à la suite d’outils Xilinx ISEversion 7.1.04i, en utilisant un FPGA de type Virtex-II (modèle XC2V1000, speedgrade -4) commecible. Comme dans le reste de ce document, les estimations de délai correspondent à la longueurdu chemin critique de chaque opérateur,mesurée grâce à des bancs de registres placés directementen entrée et en sortie de l’opérateur. De sorte à pouvoir évaluer plus précisément le surcoût desmultiplieurs par rapport aux autresméthodes, tous ces multiplieurs ont été synthétisés en utilisantla logique programmable et non les multiplieurs dédiés 18 × 18 bits.Nous donnons donc dans la figure 2.32 les résultats obtenus pour des opérateurs pour les

fonctions sin(

π4 x)et log2(1 + x), toutes deux sur l’intervalle d’entrée I = [0, 1[, évaluées pour

différents ordres d’approximation (2, 3 et 4) et à diverses précisions. En guise de comparaison,nous indiquons aussi les résultats obtenus par la méthode SMSO [DdD04], qui s’était déjà avéréeplus performante en surface comme en délai que la méthode multipartite [dDT05] ou encore laméthode quadratique présentée dans [PBM01].Comme on peut le voir sur les courbes de la figure 2.32, les opérateurs HOTBM d’ordre 2

présentent le même coût que les opérateurs équivalents SMSO. Ceci s’explique simplement parle fait que la méthode SMSO n’est autre qu’un cas particulier de HOTBM (approximation d’ordre2, avec terme linéaire réparti entre un multiplieur et une table et terme quadratique directementtabulé).Comme on pouvait s’y attendre, quel que soit l’ordre de l’approximation, la surface des opéra-

teurs augmente exponentiellement avec la précision requise. Cependant, cette explosion exponen-tielle peut être décalée vers les plus hautes précisions en augmentant l’ordre de l’approximation.La longueur du chemin critique de ces opérateurs augmente quant à elle linéairement avec laprécision, même si les opérateurs d’ordre élevé sont sensiblement plus lents que ceux d’ordreinférieur.D’après les résultats présentés ici, les approximations d’ordre 2 conviennent alors jusqu’à des

précisions de 20 à 24 bits. Il faut ensuite leur préférer des approximations d’ordre 3 jusqu’à environ28 bits de précision, avant de passer à l’ordre 4 pour pouvoir atteindre les 32 bits. Ces chiffresdépendent cependant de la fonction à approcher, comme on peut déjà le voir sur la disparitéflagrante entre les résultats pour les fonctions sin

(π4 x)et log2(1 + x).

La table 2.8 détaille diverses solutions possibles pour l’approximation de la fonction sin(

π4 x)


0

500

1000

1500

2000

2500

3000

12 16 20 24 28 32

10%

30%

50%

Précision wI = wO (en bits)

Surface (en slices) Occupation du FPGASMSOOrdre 2Ordre 3Ordre 4

(a) Surface des opérateurs pour sin`

π4x

´

.

0

500

1000

1500

2000

2500

3000

12 16 20 24 28 32

10%

30%

50%


Surface (en slices) Occupation du FPGASMSOOrdre 2Ordre 3Ordre 4

(b) Surface des opérateurs pour log2(1 + x).

20

25

30

35

40

45

50

12 16 20 24 28 32


Délai (en ns)

SMSOOrdre 2Ordre 3Ordre 4

(c) Délai des opérateurs pour sin`

π4x

´

.

20

25

30

35

40

45

50

12 16 20 24 28 32


Délai (en ns)

SMSOOrdre 2Ordre 3Ordre 4

(d) Délai des opérateurs pour log2(1 + x).

Figure 2.32 Estimations de surfaces et délais pour les fonctions sin(

π4 x)et log2(1 + x), et pour les

méthodes SMSO (ordre 2 uniquement) et HOTBM (ordre 2, 3 et 4).

pour plusieurs précisions et ordres d’approximation (n de 2 à 4). Elle nous permet de vérifierl’intuition selon laquelle les termes les plus significatifs (sauf bien entendu le terme d’ordre 0)doivent être calculés sous forme puissance et produit avec des unités d’élévation à la puissancedédiées, alors que les termes moins significatifs peuvent directement être tabulés avec une préci-sion moindre.

2.6 Conclusion

2.6.1 Contribution

LaméthodeHOTBM présentée dans ce chapitre est donc une méthode générale permettant deconstruire des opérateurs matériels pour l’évaluation de fonctions arbitraires en virgule fixe. Lesopérateurs ainsi conçus sont à la fois petits et rapides et ce pour une vaste gamme de précisionspossibles. On peut ainsi atteindre sans problème les 32 bits de précision avec des opérateurs n’oc-cupant qu’une fraction de la surface d’un FPGA, ce qui constitue une amélioration par rapport auxméthodes déjà existantes. De plus, il est toujours possible de jouer sur l’ordre de l’approximationpour explorer le compromis entre surface et délai de l’opérateur et ainsi adapter cet opérateur àtoutes sortes de contraintes.Pour faciliter la conception et l’exploration de ces opérateurs, un générateur a aussi été dé-

veloppé. En près de 5000 lignes de C++, ce générateur intègre toutes les étapes de la méthodeHOTBM décrites dans ce chapitre, depuis le calcul des polynômes d’approximation minimax

2.6 Conclusion 75

Précision n α β g Termes Surface DélaiwI = wO k type puissance αk βk λk mk (slices) (ns)16 bits 2 5 11 3 0 table – 5 – – – 135 25

1 multiplieur – 5 11 – 22 table – 2 5 – –

16 bits 3 4 12 3 0 table – 4 – – – 180 291 multiplieur – 4 12 – 22 puiss. & mult. op. dédié 4 7 8 13 table – 2 2 – –

24 bits 2 8 16 4 0 table – 8 – – – 658 331 multiplieur – 8 16 – 22 table – 4 6 – –


24 bits 4 6 18 3 0 table – 6 – – – 488 401 multiplieur – 6 18 – 12 puiss. & mult. op. dédié 6 12 14 23 puiss. & mult. table 2 3 5 14 table – 2 2 – –


32 bits 4 6 26 4 0 table – 6 – – – 1420 461 multiplieur – 6 26 – 12 puiss. & mult. op. dédié 6 20 22 13 puiss. & mult. op. dédié 6 12 18 24 table – 2 2 – –

Table 2.8 Exemples de décompositions possibles pour l’approximation de la fonction sin(

π4 x).

grâce à l’algorithme de Remez jusqu’à l’analyse d’erreur rigoureuse permettant de calculer lenombre de bits de garde requis. Grâce à une fonction de coût fournie par l’utilisateur, le géné-rateur est aussi capable d’effectuer automatiquement certaines explorations architecturales pourtrouver la solution la plus adaptée aux propriétés et contraintes du FPGA cible. Enfin, une foisl’opérateur mis au point, le programme en génère une description en VHDL, directement synthé-tisable.

2.6.2 Limitations et perspectives

Jusqu’à présent, nous n’avons considéré que les circuits reconfigurables de type FPGA commecible possible des opérateurs obtenus grâce à la méthode HOTBM. Il nous reste donc à étudierl’application de cette méthode aux circuits ASIC (Application-Specific Integrated Circuits), pourlesquels les coûts relatifs des divers composants des opérateurs HOTBM (tables, arbres d’addi-tions, multiplieurs, etc...) ne sont pas du tout les mêmes que pour des architectures FPGA. Deplus, les ASIC offrant une gamme de choix architecturaux bien plus vaste, cela nous permettraitd’optimiser encore plus finement nos opérateurs.Une direction de recherche liée à l’implémentation de ces opérateurs sur ASIC est d’étudier la

possibilité de partager le chemin de calcul entre plusieurs fonctions. De tels opérateurs multifonc-tions trouvent par exemple leur utilité dans les processeurs graphiques actuels [OS05].


Une autre question soulevée par ces travaux est liée à l’explosion du nombre de paramètresqui doivent être spécifiés pour chaque opérateur. En effet, l’ensemble des paramètres d’un opéra-teur est bien trop important pour pouvoir être exploré exhaustivement pour pouvoir rechercherla solution la plus adaptée à la fonction de coût fournie par l’utilisateur, comme cela était le caspour la méthode multipartite [dDT05]. Les heuristiques actuellement implémentées dans le géné-rateur ne sont pas capables de restreindre suffisamment l’espace d’exploration, et limitent doncsensiblement cette exploration. Il faut donc développer de nouvelles heuristiques, plus sélectivesdans les choix des paramètres à explorer.Une seconde piste d’amélioration pour la méthode HOTBM serait d’exploiter encore mieux

l’analyse d’erreur par des polynômes par morceaux pour relâcher certaines contraintes du décou-page et obtenir alors un découpage non-uniforme. On peut ainsi imaginer différentes valeurs deparamètres comme αk selon l’intervalle Ii sur lequel on se trouve. Cela permettrait de cette ma-nière de réduire encore plus la taille des différentes tables de l’opérateur. Dans la même directionse pose la question du découpage hiérarchique en segments non-uniformes, tel que présenté dans[LLVC03].Enfin, une dernière question qui reste à étudier est l’intérêt potentiel de la méthode de Hörner

pour évaluer des polynômes d’approximation dans des opérateurs matériels. Les approches dé-taillées dans la littérature [DSM97, LLVC03] sont le plus généralement naïves et ne profitent pasd’une analyse d’erreur aussi détaillée et précise que celle présentée ici. Il faut donc appliquer auschéma de Hörner les techniques d’analyse d’erreur utilisées dans le cadre de HOTBM pour pou-voir assurer une comparaison honnête entre ces deux méthodes et ainsi identifier leurs domainesd’application respectifs.

3 CHAPITRE 3

Opérateurs de base en virgule flottante etsystème logarithmique

3.1 Introduction

3.1.1 Nombres réels et FPGA

Comme nous l’avons vu dans le chapitre 1, les circuits reconfigurables FPGA sont utilisésessentiellement pour le prototypage rapide d’architectures matérielles et pour l’accélération decalculs spécifiques. Lorsque ces applications manipulent des nombres réels, ceux-ci sont le plussouvent codés en virgule fixe et non en virgule flottante. La raison en est surtout technologique :les opérateurs flottants sont plus complexes, d’autant que la structure fine du FPGA est optimiséepour la virgule fixe. Pour l’accélération de calculs, le FPGA fonctionnant à une fréquence plusfaible qu’un processeur, il doit compenser par un parallélisme massif qu’il a du mal à atteindreavec des opérateurs flottants volumineux.Cependant la capacité des FPGA augmente, et avec elle la complexité des applications qu’on

leur trouve. Certaines de ces applications ont besoin d’une dynamique de valeurs que la virgulefixe ne peut pas fournir à un coût raisonnable. Les dernières années ont donc vu la publica-tion de nombreuses applications en virgule flottante, d’abord pour la simple précision en 2002[BL02, DGL+02, GLC+02, LB02, LKM02, RN02] puis plus récemment pour la double précision[GZCP04, dD05, DVKG05]. Mais plutôt que de mimer la simple ou double précision des proces-seurs, telles que définies par la norme IEEE 754 [AI85], ces publications décrivent des formatsde virgule flottante paramétrés pour s’adapter spécifiquement aux besoins de dynamique et deprécision de chaque application.Comme nous l’avons aussi vu précédemment, la virgule flottante n’est pas la seule manière

de coder des nombres réels avec une dynamique supérieure à la virgule fixe : le système logarith-mique (LNS) permet lui aussi de représenter de tels nombres. L’intérêt de ce codage est que lesmultiplications, divisions, carrés et racines carrées sont très simples sur les logarithmes. L’incon-vénient est, bien sûr, que les additions et soustractions sont plus compliquées. L’un compensantl’autre, plusieurs publications ont montré qu’il existe des applications pour lesquelles ce systèmeétait plus performant en termes de vitesse et de surface que la virgule flottante [CCSK00,MTP+02].

3.1.2 Quelle arithmétique pour quelle application ?

Qualitativement, il est clair que l’arithmétique LNS ne peut être compétitive que si l’applica-tion remplit deux conditions : il faut que les opérations faciles (multiplication, division, carré etracine carrée) soient majoritaires sur les additions et les soustractions, et il faut que la précisionrequise soit relativement faible, car l’additionneur LNS a une taille qui croît exponentiellement

78 Chapitre 3. Opérateurs de base en virgule flottante et système logarithmique

avec la précision (voir la section 3.2.3). Quantitativement, il est plus difficile de se faire une idée.La meilleure étude comparative est sans doute celle de Coleman et al. [CCSK00] : elle porte surplusieurs algorithmes représentatifs, étudie aussi bien les erreurs numériques que les questionsd’efficacité, et compare pour deux précisions. Il est toutefois clair que ces auteurs n’ont pas ap-porté le même soin aux implémentations flottantes qu’aux implémentations LNS, ce qui biaise lescomparaisons : par exemple leur racine carrée flottante utilise une itération de Newton très inef-ficace dans ce contexte. Les opérateurs utilisés ne sont d’ailleurs pas tous décrits avec un détailsuffisant. Enfin ils n’ont qu’une technologie VLSI comme cible. Pour les FPGA, il y a l’article deMatoušek et al. [MTP+02], mais l’application qu’ils prennent en exemple frise la caricature : sonitération se compose d’une addition pour deux divisions, trois multiplications, deux carrés et uneracine carrée. On peut penser que cet algorithme est si peu représentatif qu’il ne convaincra pasun concepteur de système plus classique d’essayer le LNS.Cela dit, comme il est impossible de couvrir l’ensemble des paramètres de cette problématique

d’une manière exhaustive, notre démarche derrière les travaux présentés ici fut donc de proposernon des comparaisons mais un outil de comparaison.

3.1.3 Un outil pour une comparaison sans a priori

Ce chapitre présente ainsi FPLibrary, une bibliothèque d’opérateurs pour les nombres réelsreprésentés en virgule flottante ou en LNS. Disponible librement sous licence GPL à l’adressehttp://www.ens-lyon.fr/LIP/Arenaire/, elle permet de choisir le format de représenta-tion, la précision et la dynamique des nombres par l’intermédiaire des paramètres VHDL. Lesdeux formats partagent une syntaxe et un traitement des cas exceptionnels communs, ce qui per-met de remplacer facilement l’un par l’autre, comme détaillé dans les exemples présentés en sec-tion 3.3.2. Elle offre des opérateurs pour les cinq opérations classiques (addition, soustraction,multiplication, division et racine carrée) ainsi que les conversions utiles, en versions purementcombinatoires ou pipelinées. Enfin, de manière à assurer au mieux l’impartialité de la compa-raison, les opérateurs des deux formats ont fait l’objet d’un effort d’optimisation équivalent, desorte que les performances de ces opérateurs soutiennent la comparaison avec les opérateurs dela littérature actuelle.Notre objectif à travers cette bibliothèque est double : d’une part, permettre une étude plus

quantitative que ce qu’offre la littérature sur les avantages et inconvénients comparés du LNS etde la virgule flottante. D’autre part et plus généralement, fournir sans a priori au concepteur desystème tous les éléments pour expérimenter et choisir le codage des données le mieux adapté àson application, avec ses opérations et ses contraintes de dynamique et de précision.La première partie de ce chapitre décrit ainsi dans les grandes lignes les formats utilisés et

les architectures des différents opérateurs. La seconde partie s’intéresse ensuite à leurs surfaces etvitesses en fonction des différents paramètres, et montre que cette bibliothèque permet ainsi cettecomparaison des deux arithmétiques, au cas par cas des applications. Enfin, une brève conclusionainsi que diverses pistes d’évolutions futures pour FPLibrary viennent conclure ce chapitre.

3.2 Une bibliothèque d’opérateurs pour les nombres réels

3.2.1 Représentation des nombres

Les opérateurs de la bibliothèque FPLibrary supportent donc deux systèmes de représenta-tion des nombres réels : la virgule flottante et le système logarithmique, présentés respectivementsections 1.2.2 et 1.2.3.

3.2 Une bibliothèque d’opérateurs pour les nombres réels 79

Représentation en virgule flottante

Comme vu précédemment, une représentation en virgule flottante va être paramétrée par wE

et wF , désignant respectivement les tailles en bits de l’exposant et de la partie fractionnaire de lamantisse.Le format des nombres flottants manipulés par les opérateurs de FPLibrary est quasiment

identique à celui présenté par la norme IEEE 754, à ceci près que les nombres dénormalisés nesont pas supportés. Il n’est cependant pas exclu que la gestion de ces nombres soit rajoutée par lasuite aux opérateurs lors d’une prochaine version de la bibliothèque.Enfin, de manière à économiser du matériel pour la gestion des valeurs exceptionnelles (zéros,

infinis ou NaN), ces valeurs sont encodées en utilisant 2 bits supplémentaires appelés drapeaud’exception et notés exnX . La signification de ce drapeau est présentée table 3.1. Un nombre envirgule flottanteX est ainsi représenté par un mot de 3 + wE + wF bits, comme indiqué figure 3.1.Des opérateurs de conversion avec le format IEEE 754 classique sont aussi fournis pour pou-

voir interfacer facilement nos opérateurs avec d’autres circuits.

exnX X

00 (−1)SX × 0

01 (−1)SX × 1,FX × 2EX−E0

10 (−1)SX ×∞11 NaN

Table 3.1Valeur d’un nombreX en virgule flottante en fonction de son drapeau d’exception exnX .

SX

1

EX

wE wF

FXexnX

2

Figure 3.1 Représentation en virgule flottante d’un nombreX.

Représentation en système logarithmique

Le format de représentation des nombres en système logarithmique dans FPLibrary est luiaussi très proche du format présenté section 1.2.3. Ce format est ainsi paramétré par wI et wF

désignant respectivement les tailles en bits des parties entière et fractionnaire du logarithme LX

du nombre X. De même que pour la virgule flottante, les cas exceptionnel sont représentés demanière simple grâce au drapeau d’exception exnX , comme détaillé table 3.2. La représentationd’un nombre dans le système logarithmique occupe donc aussi 3 + wI + wF bits, comme présentéfigure 3.2.De même que pour la virgule flottante, FPLibrary intègre des opérateurs de conversion per-

mettant d’utiliser nos opérateurs LNS avec des circuits calculant en virgule flottante IEEE 754.

exnX

2

SX

1

IX

wI wF

FX,

LX

Figure 3.2 Représentation en système logarithmique d’un nombre X.


exnX X

00 (−1)SX × 0

01 (−1)SX × 2IX ,FX

10 (−1)SX ×∞11 NaN

Table 3.2Valeur d’un nombreX en système logarithmique en fonction de son drapeau d’exceptionexnX .

3.2.2 Opérateurs en virgule flottante

Cette partie n’a pas pour but de constituer un cours sur les opérateursmatériels pour la virguleflottante : il existe des livres entiers sur le sujet, par exemple [EL03] ou [FO01]. Le but est ici deconvaincre le lecteur déjà initié que notre bibliothèque est d’une qualité suffisante pour permettreune comparaison non biaisée entre système logarithmique et virgule flottante.

Addition/soustraction

L’opérateur d’addition/soustraction, dont l’architecture est présentée figure 3.3, repose surdeux chemins de calcul concurrents classiquement nommés close path (lorsque les exposants sontproches) et far path (lorsqu’ils sont lointains). Ces deux chemins permettent de réduire le chemincritique et donc le délai de l’opérateur en augmentant légèrement sa surface.Pour effectuer une addition flottante, il faut tout d’abord aligner les mantisses, puis les addi-

tionner/soustraire et enfin renormaliser le résultat. Cependant ces étapes ne sont jamais toutesnécessaires : si les exposants sont proches (close path), l’alignement des mantisses devient trèssimple, alors que dans le cas contraire (far path), c’est la normalisation finale qui est immédiate.En séparant ces deux cas mutuellement exclusifs, on gagne donc en latence au prix d’un légersurcoût matériel.

Multiplication

L’architecture du multiplieur est plus simple que celle de l’additionneur : il suffit d’effectuerle produit des mantisses des deux opérandes, et l’exposant du résultat est obtenu en prenant lasomme des deux exposants, à laquelle est soustrait le biais E0 compté une fois de trop lors de lasomme.Comme déjà expliqué dans la section 1.3.4, la portabilité de ces opérateurs est un de nos ob-

jectifs. La multiplication des mantisses est exprimée en VHDL grâce à l’opérateur *, laissant ainsià la charge des outils de synthèse de l’implémenter au mieux, au prix cependant d’une certainedistance à la solution optimale. Beuchat et Tisserand illustrent justement les diverses possibilitésd’implémentation d’une multiplication entière sur FPGA dans [BT02].

Division

L’architecture globale du diviseur est représentée figure 3.4. La mantisse du résultat est le quo-tient des mantisses des opérandes, et son exposant est la différence des deux exposants à laquelles’ajoute le biais E0. Le quotient des mantisses est effectué grâce à un algorithme SRT en base 4[EL94] sur l’ensemble de chiffre {−3,−2,−1, 0,+1,+2,+3} qui est maximalement redondant. Lechoix de la base 4 s’est avéré être la meilleure solution parmi les autres bases que nous avons étu-diées, (bases 2 et 8, ou base 4 munie d’un ensemble de chiffre moins redondant). Enfin, le quotient


+/− dé alage

normalisation �nalegestion signe et ex eptions

é hange / di�éren e

k

LZCEX

X Y

X Y

EX − EY

MY

M ′Y

EX MX

far path

close pathclose/far

dé alage / arrondi

R ≈ X + Y

wE + 1

wF + 1

⌈log (wF + 3)⌉

wF + 3

wE

MXwF + 1

MYwF + 1

wE + wF + 3 wE + wF + 3

wE + wF + 3 wE + wF + 3

wE

wF + 1

wF + 4

wF + 1

wEwF + 4

wF + 1

wE + wF + 2

wE + wF + 3

FR

ER

FR

arrondiMR

MR

Figure 3.3 Architecture de l’additionneur en virgule flottante.

étant calculé dans une base redondante, il faut réaliser une addition finale avec propagation deretenue pour repasser en binaire.

Nous avons de plus choisi de dérouler complètement la boucle d’itération de l’algorithmeSRT pour obtenir une version purement combinatoire de l’opérateur. Cela est bien sûr coûteux entermes de surface, mais permet en contrepartie de fournir un résultat par cycle d’horloge, commepour les autres opérateurs de FPLibrary.

Racine carrée

L’opérateur d’extraction de racine carrée fonctionne sur le même principe que la division :l’exposant est divisé par 2 par décalage et ajout d’un demi-biais correctif, tandis que le calculproprement dit de la racine carrée de la mantisse est obtenu par un algorithme SRT, cette fois-cien base 2 (qui s’est avérée plus intéressante que la base 4) [EL94].


arrondi

X Y

EX EY

E0

wF + 1

wE + wF + 2

wE + 1

wE + 1

wE wE wF + 2

wE + wF + 3 wE + wF + 3

wF + 1

wF + 3

wE

SRT4SRT4SRT4SRT4SRT4

M ′X M ′

Y

6

4

2

wF + 2

wF + 1wF + 2

wF + 2

wF + 2

wF + 3

normalisation �nalegestion signe et ex eptionsER

FR

M ′X

M ′Y

R ≈ X

Y

wE + wF + 3

MYMX

Figure 3.4 Architecture du diviseur en virgule flottante.

3.2.3 Opérateurs en système logarithmique

Multiplication, division et racine carrée

L’intérêt majeur du système logarithmique est la simplicité de ces opérateurs :

si R = X × Y alors LR = LX + LY ,

si R =X

Yalors LR = LX − LY , et

si R =√

X alors LR =1

2LX .

Ainsi, multiplication, division et racine carrée sont réalisées respectivement par addition, sous-traction et décalage à droite des logarithmes des opérandes. La suite de cette section se concentresur l’opérateur d’addition/soustraction.

Architecture générale de l’addition/soustraction

Effectuer une addition ou une soustraction en LNS est une opération bien plus complexe qu’envirgule flottante, car elle nécessite l’évaluation de deux fonctions non linéaires f⊕ et f⊖. En notantS et D respectivement la somme et la différence de deux nombres X et Y , avec X > Y > 0 sansperte de généralité, on a en effet :

LS = log2(2LX + 2LY )

= LX + f⊕(LY − LX), avec f⊕(z) = log2(1 + 2z), et

LD = log2(2LX − 2LY )

= LX + f⊖(LY − LX), avec f⊖(z) = log2(1 − 2z).


Le schéma de l’architecture de cet opérateur est donné figure 3.5. Le composant principal decet opérateur est bien entendu celui qui doit évaluer les fonctions f⊕(z) et f⊖(z) avec z < 0.

gestion signeex eptions

arrondi

X Y

LY − LX LX

LR

R

33

al ul def⊕ et f⊖

wI + wF + 3 wI + wF + 3

wI + wFwI + wFé hange / di�éren ewI + wF wI + wF

wI + wF

wI + wF + 3

wI + wF + 1

wI + wF + 3

wI + wF + 3

Figure 3.5 Architecture générale de l’additionneur en système logarithmique.

Implémentation de f⊕ et f⊖

Étant donnée la nature intrinsèquement non linéaire de f⊕ et f⊖, il faut passer par un schémad’approximation des ces fonctions. Dans la littérature, les solutions sont nombreuses et couvrentun vaste panorama du compromis entre vitesse et précision de l’opérateur. Ainsi, dans [TGJR88],Taylor et al. évaluent ces fonctions par de simples lectures de tables sur des intervalles bien choisispour minimiser leur taille (ordre 0). Dans [Lew90], Lewis utilise un développement de Taylord’ordre 1, qui lui permet de réduire la mémoire requise par les tables, mais rallonge sensiblementle chemin critique de l’opérateur. Enfin, dans [CCSK00], Coleman et al. présentent une méthoded’approximation utilisant un polynôme de degré 2 (ordre 2), qui diminue encore plus la tailledes tables, mais demande en contrepartie deux accès aux tables, une multiplication et quelquesadditions dans le chemin critique.Dans une première version de notre bibliothèque, nous nous sommes limités à une approxi-

mation d’ordre 1, mais sans multiplieur, en utilisant la méthode des tables multipartites [dDT05].Ce choix est amplement détaillé et justifié dans [DdD03], mais limite la précision réalisable pourcet opérateur à wF ≤ 13 bits.Dans un deuxième temps, nous nous sommes intéressés aux décompositions et simplifications

possibles de ces fonctions, et en particulier à la méthode présentée dans [PS96] et déjà reprisepar [LB03]. Cette méthode, dont l’architecture est donnée figure 3.6, calcule les fonctions f⊕(z) etf⊖(z) en évaluant séquentiellement le terme 2z puis le logarithme log2(1 ± 2z), sauf lorsque z est


proche de 0 : dans ce cas-là, la fonction f⊖(z) a une asymptote infinie en 0 qui rend son évaluationdifficile. On utilise alors la réécriture suivante pour contourner la singularité en 0 et ainsi évaluerf⊖(z) avec précision :

f⊖(z) = log2

(1 − 2z

−z

)+ log2(−z).

Cet opérateur repose donc sur l’évaluation des fonctions 2x, log2(x) et log2(−1−2x

x) qui s’ap-

prochent bien par des polynômes, contrairement à f⊕ et f⊖. Cependant, le chemin critique estconsidérablement rallongé, du fait d’une part que deux de ces fonctions doivent être évaluées sé-quentiellement, et d’autre part du mécanisme de réduction d’argument nécessaire aux fonctions2x et log2(x).

L’opérateur d’addition/soustraction en LNS ayant été développé avant la conception de laméthode HOTBM, l’évaluation proprement dite de ces fonctions repose sur la méthode SMSO,une méthode d’approximation d’ordre 2 présentée dans [DdD04], permettant ainsi d’atteindredes précisions jusqu’à wF = 23 bits. L’utilisation de la méthode HOTBM à la place de SMSO pourpouvoir atteindre des précisions supérieures est prévue, mais n’est pas prioritaire puisqu’il resteavant tout à apprécier l’intérêt d’avoir des opérateurs LNS pour ces précisions-là.

f⊕/⊖(Z)

arrondi

wF + 4

log2(x) log2

−1 − 2x

x

0wF + 2

wF + 2

wI + wF + 2

wI + wF + 2

wI + wF

Z

wI + wF

1 wF + 3

2x

−1

Figure 3.6 Architecture de l’évaluation de f⊕ et f⊖ par la méthode d’ordre 2.

Pour résumer, nous proposons dans la bibliothèque deux versions des additionneurs LNS : lapremière basée sur les tables multipartites, rapide mais volumineuse et limitée à wF ≤ 13 bits deprécision, que l’on notera O1 (ordre 1), et la seconde basée sur la décomposition de [PS96], pluslente mais plus compacte, notée O2 (ordre 2).

3.3 Compromis précision/coût/performance : quelle arithmétique pour quelle application ? 85

3.3 Compromis précision/coût/performance : quelle arithmétique pourquelle application ?

Comme cela a déjà été remarqué précédemment, les caractéristiques des opérateurs (surfaceet délai) dépendent du format de représentation des nombres, de la dynamique et de la précisionadoptés. Si les deux derniers paramètres sont imposés par l’application, le choix de l’arithmétiqueflottante ou LNS reste à effectuer. Cette section présente donc dans un premier temps les per-formances comparées des divers opérateurs isolés. Une seconde partie montre qu’une estimationplus fine peut être obtenue en synthétisant effectivement le circuit en virgule flottante et en LNS,et ce en ne changeant qu’un mot-clé dans le code VHDL. Trois exemples complets illustrent cetteméthodologie.Dans cette section, tous les chiffres sont des estimations obtenues grâce aux outils de la suite

Xilinx ISE 7.1.04i sur un FPGA de type Virtex-II XC2V1000 (speedgrade -4).

3.3.1 Comparaison des opérateurs isolés

Les courbes de la figure 3.7 donnent une idée de l’évolution des tailles et vitesses des addition-neurs dans les deux arithmétiques, en fonction des paramètres de dynamique wE = wI (comprisentre 3 et 8 bits) et de précision wF (compris entre 6 et 13 bits). Les délais sont donnés essentielle-ment à titre indicatif, en tant que mesure de la longueur du chemin critique tel que mesuré entredeux bancs de registres placés directement en entrée et sortie des opérateurs. Il va de soi, surtoutdans le cadre d’une implémentation sur FPGA, que l’on préférera en général plutôt les versionspipelinées de ces opérateurs. Il existe toutefois des applications pour lesquelles la latence importe,par exemple en cas de boucle dans le circuit. Dans un souci de clarté de ces courbes, seules lesestimations en surface et délai obtenues pour la méthode multipartite (O1) sont données pourl’additionneur LNS.Comme prévu, la surface et le délai de l’opérateur d’addition/soustraction en virgule flottante

augmentent linéairement avec les tailles de l’exposant comme de la mantisse. Le même opérateuren système logarithmique voit sa surface augmenter aussi linéairement selon wI mais de manièreexponentielle en wF . Cependant, le délai de l’additionneur en LNS reste linéaire selon wI et wF ,car la lecture des tables se fait en temps logarithmique par rapport à leur taille.De la même façon que pour les additionneurs en virgule flottante et LNS, les surfaces et délais

des opérateurs fournis par la bibliothèque dépendent essentiellement de la précision requise wF

et non de la dynamique wE . Pour cette raison, les comparaisons de ces opérateurs présentées parla suite ne tiendront compte que de wF et non de wE .Les courbes de la figure 3.8 présentent donc les estimations de surface et délai de chacun des

opérateurs. Il est à noter que les estimations de l’additionneur LNS sont données pour les deuxméthodes implémentées : ainsi sont représentées les estimations pour la méthode multipartite O1pour les précisions wF de 6 à 13 bits, et celles de la méthode O2 pour les précisions de 10 à 23 bits.On retrouve bien évidemment sur ces courbes les caractéristiques observées précédemment

pour les additionneurs. On peut aussi y remarquer que les quatre opérateurs en virgule flottanteprésentent des surfaces similaires, le diviseur restant sensiblement plus grand. Cependant, si ad-dition/soustraction et multiplication présentent des latences relativement faibles, les algorithmesà récurrence de chiffres des division et racine carrée les rendent bien plus lents. Enfin, concernantl’additionneur LNS, le compromis entre délai et surface (et par conséquent précision réalisable)apparaît distinctement, car on peut voir que la méthodeO2 est bien plus compacte que la méthodemultipartite O1, mais en contrepartie nettement plus lente.Ces courbes, bien que grossières, permettent déjà d’effectuer des estimations rapides des sur-

faces et délais de circuits donnés en fonction de la dynamique, de la précision et du système de


34

56

78 6 7 8 9 10 11 12 13

100

140

180

220

260

wE

wF

Surface (en slices)

(a) Surface de l’additionneur en virgule flottante.

34

56

78 6 7 8 9 10 11 12 13

0

1000

2000

3000

wI

wF

Surface (en slices)

(b) Surface de l’additionneur en LNS (méthode O1).

34

56

78 6 7 8 9 10 11 12 13

24

28

32

36

wE

wF

Délai (en ns)

(c) Délai de l’additionneur en virgule flottante.

34

56

78 6 7 8 9 10 11 12 13

20

24

28

32

36

wI

wF

Délai (en ns)

(d) Délai de l’additionneur en LNS (méthode O1).

Figure 3.7 Caractéristiques des additionneurs en virgule flottante (à gauche) et en LNS-O1 (àdroite). Remarquer les différences d’échelle pour les estimations de surface.

représentation adoptés. Quelques exemples numériques sont donnés dans la table 3.3.

Format Système X + Y X × Y X × Y + Z√

X2 + Y 2

(wE , wF ) = (wI , wF )

(3, 6) = 10 bitsFP 111 sl. – 25 ns 46 sl. – 19 ns 157 sl. – 44 ns 250 sl. – 84 ns

LNS-O1 114 sl. – 21 ns 9 sl. – 5 ns 123 sl. – 26 ns 133 sl. – 28 ns






LNS-O1 1019 sl. – 33 ns 14 sl. – 6 ns 1033 sl. – 39 ns 1048 sl. – 42 nsLNS-O2 553 sl. – 62 ns 14 sl. – 6 ns 567 sl. – 68 ns 582 sl. – 70 ns





Table 3.3 Exemples de comparaisons entre diverses combinaisons de dynamique (wE = wI ), pré-cision (wF ) et système de représentation des nombres, estimées en termes de surface (en slices) etde délai (en ns). Les valeurs pour les opérateurs composites sont obtenues en sommant les valeursdes opérateurs simples.

Comme mentionné précédemment, toutes les estimations précédentes ne concernent que lesversions combinatoires des opérateurs. Ceux-ci sont aussi disponibles en version pipelinée, conçue


0

100

200

300

400

500

600

6 8 10 12 14 16 18 20 22

2%

6%

10%

Précision wF (en bits)

Surface (en slices) Occupation du FPGA±×÷√

(a) Surface des opérateurs en virgule flottante.

0

500

1000

1500

2000

2500

3000

3500

4000

6 8 10 12 14 16 18 20 22

10%

30%

50%

70%


Surface (en slices) Occupation du FPGA±×÷√

O1

O2

(b) Surface des opérateurs en LNS.

20

40

60

80

100

120

140

6 8 10 12 14 16 18 20 22


Délai (en ns)±×÷√

(c) Délai des opérateurs en virgule flottante.

0

20

40

60

80

100

6 8 10 12 14 16 18 20 22


Délai (en ns)±×÷√

O1

O2

(d) Délai des opérateurs en LNS.

Figure 3.8 Caractéristiques des opérateurs en virgule flottante (à gauche) et en LNS (à droite).Remarquer les différences d’échelle en faveur de la virgule flottante pour la surface et en faveurdu LNS pour le délai.

pour une fréquence d’horloge de 100 MHz sur Virtex-II. Comme illustré par la figure 3.9, leurs ca-ractéristiques suivent à peu près celles des versions combinatoires : la surface est sensiblementplus élevée mais reste approximativement proportionnelle à celle de la version combinatoire, et laprofondeur du pipeline est aussi proportionnelle au délai de la version combinatoire.

0

200

400

600

800

1000

6 8 10 12 14 16 18 20 22

10%

20%


Surface (en slices) Occupation du FPGAVersion combinatoireVersion pipelinée

(a) Surface des opérateurs.

40

60

80

100

120

140

6 8 10 12 14 16 18 20 22

8

10

12

14

16


Délai (en ns) Profondeur du pipeline

Version combinatoireVersion pipelinée

(b) Délai/profondeur du pipeline des opérateurs.

Figure 3.9 Caractéristiques des versions combinatoire et pipelinée du diviseur en virgule flottante.


3.3.2 Détail de la méthodologie

Les estimations présentées dans la section précédente donnent une première idée, mais l’inté-rêt de notre outil est de permettre des estimations précises au cas par cas des circuits. La simplicitéde cette comparaison est montrée sur un petit exemple, celui du calcul d’une norme en dimension2 :

√X2 + Y 2. L’architecture de cet opérateur est donnée figure 3.10. Les deux élévations au carré

sont effectuées en parallèle par des multiplieurs, car notre bibliothèque n’offre pas (encore) d’opé-rateurs spécialisés, puis suivent l’addition et la racine carrée.Le code VHDL correspondant est donné par le listing 3.1. Celui-ci, tel qu’il est écrit, opère sur

des données en virgule flottante, de dynamique wE = 6 bits et de précision wF = 13 bits. Cestrois paramètres sont représentés dans le code par les constantes respectives fmt (ligne 13), wE(ligne 14) et wF (ligne 15), qui caractérisent la largeur des signaux et sont passées sous forme deparamètres génériques à tous les opérateurs de FPLibrary.

X Y

R =√

X2 + Y 2

Figure 3.10 Architecture de l’opérateur de calcul de la norme R =√

X2 + Y 2.

Ainsi, pour pouvoir changer le format de représentation des nombres, il suffit de changer lavaleur de fmt de FP (pour la virgule flottante) à LNS (pour le système logarithmique). De même,pour changer wE ou wF , il suffit de modifier la valeur de wE ou de wF, et bien sûr de répercuterce changement sur la largeur des ports d’entrée (X, ligne 7, et Y, ligne 8) et de sortie (R, ligne 9) ducomposant.En ce qui concerne l’utilisation d’opérateurs pipelinés, faire varier les paramètres est sensible-

ment plus complexe puisque la profondeur du pipeline de ces opérateurs varie avec le format et laprécision. L’ordonnancement des opérations est donc dépendant de ces paramètres, et l’utilisateurdevra typiquement insérer ou enlever des registres lorsqu’il change les paramètres. Une approcheraisonnable est donc d’étudier le choix des paramètres sur la version non pipelinée (en réservantde la surface pour le surcoût du pipeline), puis de pipeliner uniquement pour les quelques valeursdes paramètres les plus prometteuses.

3.3.3 Quelques exemples de comparaisons au cas par cas

Norme√

A2 + B2

Les courbes de la figure 3.11 présentent les surfaces et délais comparés obtenus pour le codeVHDL précédent, pour les deux systèmes de représentation des nombres. Si l’allure des courbescorrespond à peu près aux estimations de la table 3.3, on peut remarquer que les valeurs en tailleet en latence sont sensiblement plus faibles que prévues. Ceci est dû au fait que le synthétiseurVHDL remarque que X2 et Y 2 sont tous deux positifs, et qu’il est donc inutile d’implémenterla partie soustraction de l’opérateur d’addition. La simplification est d’autant plus conséquente


1 library ieee;2 use ieee.std_logic_1164.all;3 library fplib;4 use fplib.pkg_fplib.all;5

6 entity norme is7 port ( X : in std_logic_vector(6+13+2 downto 0);8 Y : in std_logic_vector(6+13+2 downto 0);9 R : out std_logic_vector(6+13+2 downto 0) );10 end entity;11

12 architecture arch of norme is13 constant fmt : format := FP;14 constant wE : positive := 6;15 constant wF : positive := 13;16

17 signal X2 : std_logic_vector(wE+wF+2 downto 0);18 signal Y2 : std_logic_vector(wE+wF+2 downto 0);19 signal R2 : std_logic_vector(wE+wF+2 downto 0);20 begin21 mul_X_X : mul22 generic map ( fmt, wE, wF )23 port map ( X, X, X2 );24

25 mul_Y_Y : mul26 generic map ( fmt, wE, wF )27 port map ( Y, Y, Y2 );28

29 add_X2_Y2 : add30 generic map ( fmt, wE, wF )31 port map ( X2, Y2, R2 );32

33 sqrt_R2 : sqrt34 generic map ( fmt, wE, wF )35 port map ( R2, R );36 end architecture;

Listing 3.1 Description VHDL de l’opérateur de calcul de la norme R =√

X2 + Y 2.

dans le cas du LNS-O1, car les tables de soustraction constitue une grande part de l’opérateur.Ceci illustre ainsi l’intérêt de faire des synthèses sur des applications complètes.Ainsi, jusqu’à wF = 16 bits, le système logarithmique sera plus intéressant pour implémenter

cet opérateur, mais au-delà des 18 bits il faudra adopter la virgule flottante, la surface de l’opéra-teur LNS commençant à être trop grande pour que le gain en délai soit une justification suffisante.

Produit scalaire

De la même façon que précédemment, on peut aisément concevoir un opérateur réalisant lecalcul d’un produit scalaire de deux vecteurs de dimension 3 en s’appuyant sur les opérateurs denotre bibliothèque. L’architecture schématisée d’un tel opérateur est donnée figure 3.12.Les courbes de la figure 3.13 montrent ainsi que dans le cas de cet opérateur, le système loga-

rithmique n’est avantageux que pour des précisions inférieures à wF = 9 bits, voire 10 bits si lavitesse est favorisée au détriment de la surface.


0

500

1000

1500

2000

2500

3000

6 8 10 12 14 16 18 20 22

20%

40%

60%


Surface (en slices) Occupation du FPGAVirgule flottanteSystème logarithmique

O1

O2


20

40

60

80

100

120

140

160

6 8 10 12 14 16 18 20 22


Délai (en ns)Virgule flottanteSystème logarithmique

O1

O2

(b) Délai des opérateurs.

Figure 3.11 Caractéristiques de l’opérateur de calcul de R =√

A2 + B2.

ByAyAx Bx Az Bz

R = AxBx + AyBy + AzBz

Figure 3.12 Architecture de l’opérateur de produit scalaire en dimension 3.

0

1000

2000

3000

4000

5000

6000

7000

8000

6 8 10 12 14 16 18 20 22

50%

100%

150%


Surface (en slices) Occupation du FPGAVirgule flottanteSystème logarithmique

O1

O2


40

60

80

100

120

140

160

180

200

6 8 10 12 14 16 18 20 22


Délai (en ns)Virgule flottanteSystème logarithmique

O1

O2

(b) Délai des opérateurs.

Figure 3.13 Caractéristiques de l’opérateur de produit scalaire en dimension 3.

Pipeline de transformation 3D

Pour ce dernier exemple, nous avons choisi d’étudier une application “grandeur nature”, lepipeline 3D. Il s’agit en fait du cœur de tous les moteurs 3D actuels qui, à partir de la descriptiond’une scène tridimensionnelle sous forme d’une liste de sommets et de triangles ainsi que de la po-sition d’une caméra, génère l’image correspondant à ce que voit la caméra. Il existe de nombreusesvariations quant aux algorithmes utilisés et aux divers traitements appliqués aux triangles, et dé-


velopper un moteur 3D complet et compétitif dépasse largement le cadre de cet exemple. C’estpour cela que nous nous sommes concentrés sur un point précis de ce pipeline, la transformation3D. Il s’agit de l’étape qui permet de passer des coordonnées des sommets des triangles dans lerepère de la scène au repère de la caméra, ceci incluant aussi les calculs de perspective. Au niveaualgorithmique, cette étape est extrêmement simple puisqu’elle repose essentiellement sur la mul-tiplication d’un vecteur P par une matriceM en dimension 4 puis deux division, comme indiquépar l’architecture de cet opérateur présentée figure 3.14.

My,wMy,zMy,yMy,x Mz,wMz,zMz,yMz,x Mw,wMw,zMw,yMw,xMx,x Mx,y Mx,z Mx,w

Rx RzRy

Px

Py

Pz

Figure 3.14 Architecture de l’opérateur de transformation 3D.

Le circuit réalisant cette transformation a été intégralement pipeliné puis implémenté sur unecarte de développement Celoxica RC1000-PP disposant d’un FPGA Virtex-E 2000 et connectée àun PC hôte grâce au bus PCI. Pour pouvoir tester complètement ce circuit, un contrôleur logiciela aussi été développé, capable d’envoyer les coordonnées des points à la carte et de récupérer lescoordonnées de ces points une fois transformés pour enfin pouvoir afficher l’image à l’écran1. Descaptures d’écran sont données figures 3.15 et 3.16.Cependant, l’étape de transformation 3D est très sensible, car elle détermine la position que

vont avoir les triangles à l’écran, et il est donc essentiel qu’elle dispose de suffisamment de pré-cision pour ne pas déformer les objets. Ainsi, si ces déformations sont quasiment invisibles surl’image de la figure 3.15, et ce malgré un calcul réalisé dans une faible précision, elles apparaissentdès que l’on commence à se rapprocher des objets et d’autant plus lorsque ceux-ci sont éloignésde l’origine de la scène. Les roues du camion dans la figure 3.16 sont ainsi un bon indicateur duniveau de précision.La figure 3.15 montre donc bien qu’une précision faible (wF = 8 bits) est suffisante pour ob-

tenir un rendu visuellement correct, à condition de ne pas trop se rapprocher des objets pour lesobserver en détail. Ainsi, selon que l’application autorise l’utilisateur à s’approcher ou non desobjets constitue un argument supplémentaire pour choisir une arithmétique plutôt qu’une autre.En effet, la précision (ici le niveau de détails) requise par une application doit être prise en comptelors du choix de l’arithmétique, et il s’agit bien d’un compromis entre surface, délai et précision

1De même que pour tous les opérateurs de FPLibrary, cette application est aussi disponible sous licence GPL à lamême adresse que la bibliothèque.


Figure 3.15 Image calculée en système logarithmique avec une faible précision (wI , wF ) = (5, 8).

des opérateurs qu’il faut explorer pour pouvoir enfin choisir l’arithmétique la plus adaptée à cetteapplication.Dans le cadre de notre exemple, les captures d’écran de la figure 3.16 témoigne d’une informa-

tion supplémentaire, difficilement prévisible a priori : pour une précision équivalente, l’opérateuren virgule flottante donne un résultat légèrement plus correct que le système logarithmique. Ainsi,la virgule flottante avec wF bits de précision présente ici des résultats plus précis que le LNS avecaussi wF bits de précision, mais cependant moins précis qu’en LNS avec wF + 1 bits de précision.Les opérateurs doivent donc être comparés en tenant compte de ce facteur supplémentaire.Il est important de noter que ce comportement de la précision en fonction du système de re-

présentation est propre à l’application choisie ici. Il est tout à fait envisageable de rencontrer desapplications pour lesquelles la tendance sera renversée : en effet, en LNS, multiplications et divi-sions étant exactes, une application reposant plus sur ces opérations sera naturellement avantagéeen termes de précision par rapport à la virgule flottante.Les résultats donnés par l’implémentation des diverses versions de cet opérateur nous per-

mettent aussi de constater que l’opérateur en système logarithmique est deux fois plus rapide queson équivalent en virgule flottante, même si ceci est naturellement équilibré par le fait que cesdeux opérateurs soient pipelinés à la même fréquence. L’opérateur LNS est par contre deux foisplus grand que l’opérateur en virgule flottante, ce qui justifie d’autant plus le choix de la virguleflottante pour cette application particulière.Enfin, nous tenons à rappeler que l’exemple présenté ici n’a pas pour ambition de vouloir

concurrencer ou remplacer les processeurs graphiques actuels, dont l’architecture spécifique seprête bien mieux à ces opérations. Le but de cet exemple est uniquement d’illustrer comment notrebibliothèque FPLibrary peut être utilisée pour explorer rapidement et précisément les compromisentre surface, délai et précision pour n’importe quelle application.


(a) FP, (5, 8), 4446 slices (23%), 25 cycles. (b) LNS-O1, (5, 8), 5497 slices (28%), 14 cycles.

(c) FP, (5, 9), 4802 slices (25%), 25 cycles. (d) LNS-O1, (5, 9), 7415 slices (38%), 14 cycles.

(e) FP, (5, 10), 5246 slices (27%), 26 cycles. (f) LNS-O1, (5, 10), 9701 slices (50%), 14 cycles.

Figure 3.16 Images calculées pour les deux systèmes de représentation et avec diverses précisions.Les estimations de surface sont indiquées pour le FPGA cible, un Virtex-E 2000, et les informationsde délai sont données par la profondeur du pipeline de l’opérateur.


3.4 Conclusion

3.4.1 Contribution

Nous espérons pouvoir montrer grâce à ces travaux qu’il est bien plus convaincant, pour dis-cuter des avantages comparés des arithmétiques logarithmique et flottante, de donner un accèslibre à une bibliothèque d’opérateurs de qualité, que de publier des comparaisons ponctuelles,spécifiques à une application donnée. Un effet de bord non négligeable de ces travaux est naturel-lement l’existence de cette bibliothèque, que nous cherchons toujours à étendre et perfectionner.Un témoin significatif du besoin de la communauté pour une telle bibliothèque est le constat

que, depuis que cette bibliothèque a été publiée en 2003, plusieurs équipes de recherche, acadé-miques pour la plupart, l’ont adoptée pour leurs propres travaux. Ainsi, FPLibrary est ou a étéutilisée entre autres au Laboratoire de Recherche en Informatique (LRI) de l’Université de Paris-Sud [EL05], au Los Alamos National Laboratory (LANL) aux États-Unis [GFA+04], au FGANResearch Institute for Optronics and Pattern Recognition (FGAN-FOM) à Ettlingen en Allemagne,au Department of Electrical and Electronic Engineering de l’Université de Honk-Kong, ou encorepar l’entreprise Gaisler Research, en Suède.

3.4.2 Perspectives

Les opérateurs flottants sont sans doute difficiles à améliorer en restant en VHDL portable,pour preuve la ressemblance presque parfaite entre notre bibliothèque et celle de Lee et Burgess[LB02], réalisée indépendamment.Par contre l’additionneur en système logarithmique peut encore faire l’objet de plusieurs amé-

liorations en diversifiant les méthodes d’implémentation de cet opérateur, permettant ainsi à l’uti-lisateur de se positionner précisément dans le compromis surface-délai selon la précision qu’il re-quiert. Dans l’état actuel, notre additionneur LNS ne permet pas de dépasser la simple précision,et atteindre la double précision demandera des efforts bien plus importants, comme en témoigne[HBW+05], où ni l’additionneur ni le soustracteur LNS présentés par les auteurs ne tiennent dansun FPGAXilinx Virtex-II 2000 (disposant de 10752 slices et 56 blocks demémoire). Nous comptonsdonc pour cela essayer d’utiliser des méthodes d’ordre supérieur pour l’évaluation des fonctionsnécessaires, comme par exemple la méthodeHOTBMprésentée précédemment. Cependant, avantde nous lancer sur cette piste, nous devons d’abord nous convaincre de l’intérêt de la chose, à sa-voir qu’il existe de vraies applications nécessitant l’utilisation du système logarithmique à de tellesprécisions.Enfin, de même que pour les résultats présentés dans le chapitre précédent, il est sans doute

vain de vouloir généraliser les résultats quantitatifs obtenus sur FPGA à des circuits ASIC : lesdeux technologies sont tellement différentes qu’il semble illusoire de croire que les choix architec-turaux que nous avons fait en ciblant les FPGA sont aussi adaptés aux circuits VLSI. Il faudra doncsûrement à terme développer des générateurs de VHDL capables de faire tous ces choix en fonc-tion d’une fonction de coût spécifiée par l’utilisateur, comme c’est déjà le cas pour les opérateursde la méthode HOTBM.

4 CHAPITRE 4

Fonctions élémentaires en virguleflottante

4.1 Introduction

Le développement des opérateurs de base dans FPLibrary constitue déjà une première étapevers une “démocratisation” de la virgule flottante sur FPGA, c’est-à-dire simplifier le portage surFPGA d’algorithmes numériques logiciels, le plus souvent écrits en virgule flottante. L’étape natu-relle suivante est donc de fournir aussi des opérateurs pour l’évaluation de fonctions élémentaires,toujours en virgule flottante.Implémenter ces fonctions élémentaires en virgule flottante sur FPGA est un problème diffé-

rent de ce que l’on peut trouver dans la littérature : la flexibilité des circuits reconfigurables permetd’utiliser des algorithmes spécifiques qui s’avèrent être plus efficaces qu’une implémentation enmicro-code sur des processeurs pourtant bien plus performants. Ainsi, si les opérateurs de basesont généralement environ dix fois plus lents que leurs équivalents sur un processeur cadencéà quelques gigahertz [LMM+98, Und04], nous montrons ici que la tendance s’inverse pour lesfonctions élémentaires jusqu’à la simple précision.Si la plupart, sinon l’intégralité, des systèmes actuels est capable d’évaluer ces fonctions, cette

évaluation est toujours effectuée en logiciel ou en micro-code : le consensus actuel est tel qu’il estplus intéressant d’utiliser les unités flottantes déjà existantes pour évaluer une fonction grâce à unalgorithme logiciel plutôt qu’un opérateur matériel dédié [PW76, Tan91, Mar00, Mul05a].De plus, comme il s’agit ici d’une extension intégrée à FPLibrary, il faut que ces opérateurs res-

tent compatibles avec les opérateurs précédents de la bibliothèque. Ainsi, le format des nombresen virgule flottante est toujours paramétré en termes de précision (wF ) et de dynamique (wE).Dans la littérature, seuls deux articles abordent le sujet des fonctions élémentaires sur FPGA,

présentant les fonctions sinus [OHDP03] et exponentielle [DR04]. Cependant, les algorithmesd’évaluation utilisés dans ces deux travaux restent trop proches des algorithmes logiciels et neprofitent pas du tout de la souplesse architecturale offerte par les FPGA, comme en témoignentles résultats présentés dans les sections 4.2.4, 4.3.4 et 4.4.4.La contribution de ces travaux est donc multiple. Du point de vue de la méthodologie, notre

approche est aussi novatrice par rapport aux algorithmes existants : plutôt que d’effectuer tousles calculs intermédiaire en virgule flottante, que l’on sait moins performante que la virgule fixe,nous proposons ici de se débarrasser dès la réduction d’argument de ce format de représentationpour n’avoir plus que des calculs en virgule fixe jusqu’à la reconstruction finale du résultat. Deplus, comme pour les opérateurs présentés dans les chapitres précédents, la conception de chaqueopérateur s’accompagne d’une analyse d’erreur rigoureuse, permettant d’optimiser finement leschemins de données.Ce chapitre décrit donc successivement trois opérateurs pour les fonctions élémentaires en vir-

96 Chapitre 4. Fonctions élémentaires en virgule flottante

gule flottante intégrés dans FPLibrary, à savoir le logarithme, présenté section 4.2, l’exponentielle,section 4.3 et enfin les fonctions trigonométriques sinus et cosinus, section 4.4. Pour chaque fonc-tion sont présentés l’algorithme d’évaluation, l’architecture de l’opérateur, l’analyse d’erreur etenfin des estimations en termes de surface et de délai de l’opérateur en fonction de divers para-mètres.Enfin, si logarithme et exponentielle offrent des implémentations tout à fait satisfaisantes,

l’opérateur pour les fonctions trigonométriques est pour sa part pénalisé par une réduction d’ar-gument difficile. Nous proposons donc aussi quelques implémentations alternatives, permettantde couvrir le compromis entre précision, coût et performance pour cet opérateur.

4.2 Logarithme

4.2.1 Algorithme d’évaluation

Réduction d’argument

On se place ici dans le cas où X est un nombre strictement positif représenté en virgule flot-tante. Dans le cas contraire, l’opérateur doit retourner NaN. On a ainsi :

X = 1,FX · 2EX−E0 .

On notant r = log X, on obtient :

r = log(1,FX

)+ (EX − E0) · log 2.

Dans ce cas, il suffit alors de calculer la valeur de log(1,FX

)avec 1 ≤ 1,FX < 2 et d’y ajouter

le produit (EX − E0) · log 2 pour obtenir le résultat final.Cependant, lorsque X est proche de 1 par valeurs inférieures, on a EX − E0 = −1 et 1,FX

proche de 2, ce qui nous donne :

r = log(1,FX

)+ (EX − E0) · log 2 ≈ log 2 − log 2.

L’addition finale va alors provoquer une annulation catastrophique des bits de poids fort et doncune grande perte de précision sur le résultat.Pour éviter cela et ainsi être capable de garantir un résultat précis, on utilise la formule sui-

vante pour centrer l’intervalle de sortie du calcul de log(1,FX

)autour de 0 :

r = log M + E · log 2,

avec : {M = 1,FX et E = EX − E0 lorsque 1,FX ∈ [1,

√2[, et

M = 0,1FX et E = EX − E0 + 1 lorsque 1,FX ∈ [√

2, 2[.

De cette manière, on a√

22 ≤ M <

√2, ce qui donne :

−1

2log 2 ≤ log M <

1

2log 2.

4.2 Logarithme 97

Logarithme en virgule fixe

Comme cet opérateur calcule en virgule flottante, il faut évaluer log M avec une précisionsuffisante pour pouvoir garantir l’arrondi fidèle, même après une possible renormalisation du ré-sultat. Or, log M pouvant être aussi proche que possible de 0, une évaluation directe cette fonctiondemanderait une précision d’au moins 2wF bits : comme la normalisation finale peut nous faireperdre jusqu’à wF bits, il nous faut wF bits significatifs supplémentaires.On peut cependant voir que lorsqueM est proche de 1, log M est quant à lui proche deM − 1.

Ainsi, une approche en deux étapes, consistant d’abord à évaluer log MM−1 avec une précision de

wF + g0 bits puis à multiplier cette valeur par M − 1, calculé exactement, permet d’atteindre laprécision cible à un coût bien moindre.L’évaluation en virgule fixe de la fonction log M

M−1 est réalisée grâce à la méthode HOTBM pré-senté au chapitre 2. Le degré de l’approximation polynomiale adoptée dépend de la précisionrequise.

Reconstruction

Le signe du résultat r est pour sa part indépendant de la réduction d’argument et peut doncêtre calculé en parallèle de celle-ci. Ainsi, on sait que r sera positif ou nul lorsque EX ≥ E0, etnégatif dans le cas contraire.Étant donné que l’on souhaite un résultat en virgule flottante, on cherche donc tout d’abord à

calculer Y , la valeur absolue du résultat représentée en virgule fixe. On a ainsi selon le signe de r :

Y =

(M − 1) ·(

log M

M − 1

)+ E · log 2 lorsque r ≥ 0, et

−(M − 1) ·(

log M

M − 1

)− E · log 2 lorsque r < 0.

En parallèle de l’évaluation de log MM−1 , on peut donc calculer les opposés de M − 1 et de E en

fonction du signe de r pour n’avoir plus comme reconstruction que le calcul des deux produits

(M − 1) ·(

log MM−1

)et E · log 2 puis enfin leur somme pour obtenir Y .

À partir de Y , on peut alors reconstruire R, la représentation en virgule flottante du résultat r,grâce à une normalisation et un arrondi qui nous donnent sa mantisse 1,FR et son exposant ER.Le signe SR de R est pour sa part obtenu directement avec le signe de r.

4.2.2 Architecture

L’architecture du logarithme est donnée figure 4.1. Il s’agit d’une implémentation directe del’algorithme présenté précédemment. Du fait de son flot de données purement séquentiel, cetopérateur se prête très bien au pipeline. Enfin, les nombres de bits de garde g0 et g1 sont explicitésdans la section suivante.Quelques remarques et commentaires sur cette architecture :– Dans le calcul de l’argument M à partir de la valeur de la mantisse 1,FX , il est importantde noter que la frontière

√2 entre les deux intervalles n’a pas besoin d’être aussi précise

que cela. Ainsi, seuls quelques bits de√

2 suffisent pour la comparaison pour éviter touteannulation catastrophique des bits du résultat lors de la somme finale.

– Le signe de r (et donc de R) est directement obtenu à partir du signe de EX − E0.– Comme mentionné avant, l’évaluation en virgule fixe de log M

M−1 est réalisée grâce à une ins-tance d’un opérateur HOTBM pour une précision de wF + g0 bits.


1 + wF

1 + wF

1 + wF

wE

2 1 wE wF

3 + wE + wF

X

exnX SX EX FX

1

1 + wF

√2

E0

1

±1

wE + 1

wF + g0 + 2

E

M

log M

M − 1

SR

wF + g1

log 2

±1

wE

wE + wF + g1

wE + 2wF + g0 + 2

2wF + g0 + 3

3 + wE + wF

R ≈ log X

gestion signe et ex eptionsYnormalisation / arrondiFigure 4.1 Architecture du logarithme en virgule flottante.

– La normalisation finale doit extraire de Y , la valeur absolue du résultat représentée en vir-gule fixe, l’exposant et la mantisse de sa représentation en virgule flottante. On utilise pourcela un compteur de zéros en poids fort (Leading-Zero Counter) ainsi qu’un décaleur. Cedécalage peut être d’au plus wF bits vers la gauche ou wE − 2 bits vers la droite.En effet, la plus petite valeur non nulle de Y sera obtenue pourX = 1 + 2−wF (qui donneraY ≈ 2−wF ) et la plus grande pourX = (2−2−wF )·2E0 (soit Y ≈ (E0+1)·log 2 = 2wE−1 ·log 2).– Enfin, les éventuels cas de dépassement de capacité vers 0 (underflow) sont gérés par l’unitéde gestion des exceptions.

La taille des tables utilisées par la méthode HOTBM augmentant de manière exponentielleavec la précision wF de l’opérateur, cette architecture convient permet bien d’atteindre la simpleprécision (wF = 23 bits) comme le confirment les résultats présentés plus loin.

4.2 Logarithme 99

4.2.3 Analyse d’erreur

D’après le dilemme du fabriquant de tables [LMT98], garantir l’arrondi correct du résultat de-manderait de calculer Y avec une précision bien supérieure à la précision cible. Nous nous conten-tons plutôt ici d’assurer l’arrondi fidèle, c’est-à-dire une erreur de moins d’un ulp du résultat. Celacorrespond à une erreur absolue d’un bit sur la mantisse du résultat R :

|r − R|2ER−E0

=

∣∣∣∣|r|

2ER−E0− 1,FR

∣∣∣∣ < 2−wF .

Or, on sait que la mantisse 1,FR de R est obtenue à partir du nombre en virgule fixe Y qui estsuccessivement normalisé puis arrondi. Cette normalisation consiste en un décalage à droite deER − E0 = ⌊log2 Y ⌋ bits qui nous donne le nombre Z avec :

1 ≤ Z = Y · 2−⌊log2 Y ⌋ < 2.

Pour parvenir à la mantisse de R, Z est ensuite arrondi au plus proche à wF bits de partie frac-tionnaire, ce qui induit une erreur additionnelle d’au plus un demi ulp, soit 2−wF−1.La contrainte précédente nécessaire à l’arrondi fidèle nous donne donc pour Z :

∣∣∣∣|r|

2ER−E0− Z

∣∣∣∣ < 2−wF−1,

d’où l’on déduit alors la contrainte de précision sur Y :∣∣∣∣

|r|2ER−E0

− Y · 2−⌊log2 Y ⌋∣∣∣∣ =

||r| − Y |2⌊log2 Y ⌋ < 2−wF−1,

soit enfin :||r| − Y | < 2−wF−1 · 2⌊log2 Y ⌋.

Il nous faut alors étudier différents cas selon la valeur de E :– Lorsque |E| > 3, on a Y > 2, et l’erreur prédominante est due à l’erreur de discrétisationcommise sur la constante log 2, arrondie à wF + g1 bits de partie fractionnaire. Cette erreurest ensuite multipliée par ±E.

– À l’inverse, lorsque E = 0, la seule erreur commise est l’erreur d’évaluation de log MM−1 , qui est

ensuite multipliée par ±(M − 1).– Lorsque |E| = 2 ou 3, à la fois l’erreur sur log 2 et sur log M

M−1 doivent être prises en compte.Cependant, dans ce cas-là, on a toujours Y > 1, ce qui signifie que la renormalisation de Yn’amplifiera pas cette erreur en la décalant vers la gauche.

– Enfin, lorsque |E| = 1, l’erreur est aussi due à la fois à la discrétisation de log 2 et à l’évalua-tion de log M

M−1 , mais on a cette fois-ci l’encadrement suivant sur Y :

0,34 <1

2log 2 ≤ Y ≤ 3

2log 2 < 1,04.

Dans ce cas, la renormalisation entraînera un décalage d’au plus deux bits vers la gauche, cequi correspond à une multiplication de l’erreur par un facteur au plus 4.

Ainsi, en calculant l’erreur commise dans chacun de ces quatre cas, on peut facilement endéduire les valeurs minimales des nombres de bits de garde g0 et g1. On trouve alors g1 = 3 bitsainsi que la contrainte que l’erreur commise par l’opérateur HOTBM calculant log M

M−1 soit inférieureà 2−wF−3, ce qui nous donne g0 généralement compris entre 2 et 5 bits.La validité de cette analyse d’erreur a pu être vérifiée en effectuant des tests exhaustifs de

nos opérateurs sur une carte de développement Celoxica RC1000-PP embarquant un FPGA Xilinx


Virtex-E 2000. Les valeurs retournées par les opérateurs ont ainsi pu être comparées aux valeursthéoriques calculées en double précision sur l’ordinateur hôte, et ce pour tous les jeux de para-mètres avec 3 ≤ wE ≤ 8 et 6 ≤ wF ≤ 23. Ces tests ont pu montrer que tous les résultats respec-taient bien la contrainte de l’arrondi fidèle, et qu’ils étaient même correctement arrondis dans 98%des cas.

4.2.4 Résultats

Comme pour les opérateurs présentés dans les chapitres précédents, les estimations de surfaceet de délai des opérateurs données ici ont été obtenues après synthèse, placement et routage àl’aide des outils de la suite Xilinx ISE version 7.1.04i pour un FPGA cible Virtex-II XC2V1000-4.Ces estimations, réalisées en fonction des paramètres wE et wF jusqu’à la simple précision, sontreprésentées figure 4.2 et quelques exemples sont détaillés dans la table 4.1.

34

56

78 6 8 10 12 14 16 18 20 22

0

400

800

1200

1600

wE

wF

Surface (en slices)

(a) Surface en fonction de wE et wF .

34

56

78 6 8 10 12 14 16 18 20 22

30

50

70

90

wE

wF

Délai (en ns)

(b) Délai en fonction de wE et wF .

0

250

500

750

1000

1250

1500

6 8 10 12 14 16 18 20 22

10%

20%

30%


Surface (en slices) Occupation du FPGA

(c) Surface en fonction de wF , avec wE = 8 bits.

30

40

50

60

70

80

90

6 8 10 12 14 16 18 20 22


Délai (en ns)

(d) Délai en fonction dewF , avec wE = 8 bits.

Figure 4.2 Caractéristiques en surface (à gauche) et en délai (à droite) de l’opérateur pour le loga-rithme en virgule flottante.

Dans un souci de portabilité, les opérateurs ne nécessitent pas forcément l’utilisation des petitsmultiplieurs 18 × 18 bits présents dans les modèles récents de FPGA. Cependant, ces opérateurspeuvent bien entendu tirer parti de ces multiplieurs si ceux-ci sont disponibles. Nous présentonsdonc figure 4.3 et table 4.1 les résultats pour les deux alternatives : multiplieurs synthétisés sur lalogique du FPGA, ou bien sur les petits multiplieurs dédiés. On peut ainsi constater qu’en simpleprécision les multiplieurs occupent plus d’un tiers de la surface de l’opérateur et qu’il peut doncêtre intéressant d’implémenter ces multiplieurs grâce à des opérateurs dédiées si le FPGA cible lesupporte.Si la plupart des résultats présentés ici concernent la version combinatoire de l’opérateur, nous

4.2 Logarithme 101

Précision Multiplieurs Surface Délai(wE , wF ) (slices % mults) (ns)

(3, 6) logique 129 (2%) – 3718 × 18 101 (1%) 2 35

(5, 10) logique 271 (5%) – 4918 × 18 156 (3%) 3 46

(6, 13) logique 439 (8%) – 5718 × 18 247 (4%) 3 50

(7, 16) logique 619 (12%) – 6918 × 18 355 (6%) 6 68

(8, 23) logique 1447 (27%) – 8618 × 18 876 (16%) 9 76

Table 4.1 Surface et délai de l’opérateur pour le logarithme pour diverses précisions.

0

250

500

750

1000

1250

1500

6 8 10 12 14 16 18 20 22

2

4

6

8

10


Surface (en slices) Multiplieurs 18 × 18

Mults en logiqueMults 18 × 18 (slices)Mults 18 × 18 (mults)

(a) Surface en fonction de wF , avec wE = 8 bits.

30

40

50

60

70

80

90

6 8 10 12 14 16 18 20 22


Délai (en ns)

Mults en logiqueMults 18 × 18

(b) Délai en fonction dewF , avec wE = 8 bits.

Figure 4.3 Caractéristiques comparées en surface (à gauche) et en délai (à droite) de l’opérateurselon l’utilisation ou non des petits multiplieurs 18 × 18.

l’avons aussi finement pipeliné à 100MHz sur le FPGA cible au prix d’un léger surcoût matériel,comme le montre la comparaison de la figure 4.4. La profondeur du pipeline dépend évidemmentdes paramètres wE et wF , et est ici comprise entre 5 et 11 cycles.

0

250

500

750

1000

1250

1500

6 8 10 12 14 16 18 20 22

10%

20%

30%


Surface (en slices) Occupation du FPGAVersion combinatoireVersion pipelinée


30

40

50

60

70

80

90

6 8 10 12 14 16 18 20 22

5

6

7

8

9

10

11




(b) Délai en fonction de wF , avec wE = 8 bits.

Figure 4.4 Caractéristiques comparées en surface (à gauche) et en délai (à droite) de l’opérateurentre versions combinatoire et pipelinée.

Enfin, la table 4.2 compare les performances de l’opérateur pour le logarithme en simple préci-


sion (wE , wF ) = (8, 23) avec celles mesurées sur un processeur Intel Xeon cadencé à 2,4 GHz uti-lisant la fonction logarithme définie dans la libc GNU (reposant elle-même sur les instructionsmicro-codées fyl2x et fyl2xp1). Comme le montre ce tableau, malgré une fréquence d’horlogebien moindre, l’implémentation complètement pipelinée de l’opérateur sur FPGA permet d’at-teindre des débits supérieurs à ceux du processeur généraliste qui n’est pas enmesure de pipelinerses calculs de la même manière.

Cible Cycles Délai (ns) Débit (106 op/s)Intel Xeon à 2,4 GHz 196 82 12

FPGA Virtex-II à 100MHz 11 64 100

Table 4.2 Performances comparées de l’opérateur avec un processeur Intel Xeon, en simple préci-sion.

Il convient cependant de tempérer ces résultats par quelques remarques. Tout d’abord, notreopérateur est sensiblement moins précis que l’algorithme logiciel, car le Xeon calcule avec uneprécision interne de 80 bits, ce qui lui assure l’arrondi correct du résultat dans la plupart descas. De plus, les jeux d’instructions plus récents offrent des latences moindres pour les fonctionsélémentaires. Ainsi, le processeur Intel Itanium 2 peut calculer un logarithme simple précisionen 32 cycles puis fournir un résultat presque tous les 5 cycles [TOML04], soit un débit de prèsde 300 · 106 calculs par seconde pour un processeur cadencé à 1,5 GHz. Cependant, l’argumentdu parallélisme massif, qui consiste à mettre plusieurs opérateurs en parallèle sur le FPGA pouraugmenter le débit, est toujours valable.

4.3 Exponentielle


Cas particuliers

Même si la fonction exponentielle est définie sur l’ensemble des nombres réels, les nombresreprésentables en virgule flottante sont encadrés en valeur absolue par :

Xmin ≤ X ≤ Xmax,

avec : {Xmin = 21−E0 , et

Xmax = (2 − 2−wF ) · 2E0 .

Ainsi, la fonction exponentielle doit renvoyer 0 (underflow) pour tous les opérandes plus pe-tits que log Xmin = (1−E0) · log 2 = (2−2wE−1) · log 2, et+∞ (overflow) pour tous ceux supérieursà log Xmax < (1 + E0) · log 2 = 2wE−1 · log 2. Nous nous restreindrons donc dans la suite à des opé-randes compris dans l’intervalle

[(2 − 2wE−1) · log 2, 2wE−1 · log 2

[.

Algorithme naïf

L’idée immédiate pour calculer l’exponentielle r d’un nombre X en virgule flottante est d’uti-liser l’égalité suivante :

r = eX = 2

“X

log 2

”

.

4.3 Exponentielle 103

Il suffit alors de calculer en virgule fixe le produit de X par 1log 2 , noté Y = IY ,FY . La partie

entière IY correspondra donc à l’exposant ER − E0 de la représentation en virgule flottante durésultat R, et 20,FY nous donnera sa mantisse 1,FR.Cependant, cette méthode pose plusieurs problèmes :– Le produit de X par 1

log 2 doit être calculé avec une grande précision pour garantir la préci-sion du résultat. Une analyse d’erreur rapide nous montre ainsi qu’il faut au moins wE +wF

bits de partie fractionnaire pour la constante 1log 2 , ce qui implique un très gros multiplieur

pour le calcul du produit par X.– L’évaluation précise de 20,FY sera elle aussi coûteuse puisqu’il lui faut wF bits en entrée.Le second problème peut être simplement résolu en utilisant une seconde réduction d’argu-

ment, découpant ainsi FY en deux sous-mots FY,1 et FY,2, FY,1 représentant les p bits de poids fortde FY , et FY,2 les bits de poids faible restants :

0,FY = 0,FY,1FY,2 = 0,FY,1 + 0,FY,2 · 2−p.

On peut alors écrire :

20,FY = 20,FY,1 · 20,FY,2×2−p

,

où le premier terme sera directement tabulé et le second évalué par uneméthoded’approximation.Cependant, la reconstruction demande toutefois une multiplication supplémentaire, ici de l’ordrede wF bits par wF − p bits.

Algorithme amélioré

Un algorithme un peu plus complexe, plus proche de ce qui est généralement fait en logiciel[TOML04], permet de résoudre les deux problèmes précédents. L’idée principale ici est de réduirel’argumentX à un entier k et un nombre en virgule fixe Y ∈

]−1

2 , 12

[tels que :

X ≈ k · log 2 + Y ,

pour ensuite calculer :r = eX ≈ 2k · eY .

Cette réduction d’argument est réalisée en deux étapes : tout d’abord le calcul de k, obtenucomme un arrondi à l’entier le plus proche du produit en virgule fixe deX par 1

log 2 , puis le calculde Y comme la différence deX et de k · log 2.On peut ensuite appliquer la même réduction que précédemment pour le calcul de eY , en

découpant Y en Y1 et Y2 :Y = Y1 + Y2,

avec Y1 les p bits de poids fort de la partie fractionnaire de Y et 0 ≤ Y2 < 2−p. On calcule alors :

eY = eY1 × eY2 ,

en tabulant la valeur de eY1 .Cette méthode est meilleure que la précédente pour deux raisons principales. La première est

que le calcul de k ne nécessite pas d’être précis, car le calcul de Y comme une différence permettrade compenser l’erreur commise sur k. Le calcul de k sera ainsi réalisé grâce à un petit multiplieur,et celui de Y ne nécessitera qu’un multiplieur rectangulaire pour calculer le produit du petit entierk par la constante log 2. Cependant, comme k est cette fois-ci approché, l’exposant du résultat serak ± 1, ce qui signifie qu’une normalisation finale de la mantisse sera nécessaire.


De plus, le calcul de eY2 est ici bien plus simple que le calcul de 2FY,2 requis par l’algorithmeprécédent. En effet, comme Y2 est très proche de 0, on a la formule de Taylor suivante :

eY2 = 1 + Y2 + f(Y2),

avec :f(Y2) = eY2 − 1 − Y2 =

1

2Y 2

2 + O(Y 32 ).

On peut ainsi vérifier que, comme 0 ≤ Y2 < 2−p, on a bien 0 ≤ f(Y2) < 2−2p, ce qui permet desimplifier grandement la table servant à évaluer cette fonction.Enfin, la reconstruction est elle aussi relativement simple, puisque :

eY = eY1 × eY2

= eY1 × (1 + Y2 + f(Y2))

= eY1 + eY1 × (Y2 + f(Y2)) ,

ce qui va nous permettre d’utiliser ici aussi un multiplieur rectangulaire de l’ordre de wF bits parwF − p bits suivi d’une simple addition.

Discussion sur les tables

L’algorithme précédent utilise donc deux tables :– La première, adressée par p bits, contient les valeurs de eY1 sur une grande précision (del’ordre de wF bits), et ne peut donc être compressée grâce aux méthodes classiques dérivéesde la méthode bipartite.– Par contre, la seconde, adressée par les wF − 2p bits de poids fort de Y2 et calculant la fonc-tion f(Y2) sur autant de bits, peut pour sa part être optimisée grâce à ces méthodes à basede table. Tout comme pour le logarithme, nous utilisons donc la méthode HOTBM pourimplémenter cette table.Cependant, avec ou sans compression, la taille de ces tables augmente de manière exponen-

tielle avec la taille de leur opérande. Ainsi, de même que pour le logarithme, cet algorithme estadapté à des précisions jusqu’à la simple précision (wF = 23), comme le confirment les résultatsprésentés section 4.3.4.Bien sûr, pour de plus faibles précisions, l’algorithme complet pour le calcul de eY peut être

grandement simplifié, voire même implémenté comme une seule table de valeur.

4.3.2 Architecture

L’architecture de cet opérateur est présentée figure 4.5. Il s’agit là aussi d’une implémentationdirecte de l’algorithme détaillé plus haut et, encore une fois, elle peut être aisément pipelinée dufait de sa structure séquentielle.Cette architecture a deux paramètres, p et g. Le premier, défini plus haut, permet de contrôler le

compromis entre les tailles des deux tables de l’opérateur, et sa valeur est généralement compriseentre 1

4wF et 13wF . Le second désigne le nombre de bits de garde nécessaires pour garantir la

précision du résultat R.Quelques points de cette architecture méritent aussi des commentaires :– L’opérateur de décalage se charge de décaler la mantisse signée ±1,FX selon la valeur del’exposant EX −E0 pour obtenirXfix, la représentation deX en virgule fixe. Le décalage dela mantisse est d’au plus wE − 1 bits vers la gauche (si le décalage dépasse cette valeur c’estqu’il s’agit d’un dépassement de capacité vers 0 ou vers +∞) et d’au plus wF + g bits vers la


3 + wE + wF

R ≈ eX

3 + wE + wF

X

1

1 + wF

±1

2 + wF

wE + wF + g Xfix1/ log 2

wE + 1kwE + wF + g − 1

log 2

2wE + wF + g

wF + g

p wF + g − pY1 Y2

wF + g − 2p

wF + g − 2p + 1

eY2 − Y2 − 1eY1

wF + g

wF + g − p

wE

E0

wE + 1

wF + g

Y

eY

under�owover�ow/wE + 4wE + 2

dé alagearrondi

2 1 wE wF

exnX SX EX FX

normalisation / arrondigestion signe et ex eptions

wF + g − p + 1

Figure 4.5 Architecture de l’exponentielle en virgule flottante.


droite (car lorsqueX est proche de 0, eX est proche de 1, donc seuls wF + g bits de précisionsuffisent). Le résultat du décalage est ensuite tronqué à ses 1 + wE + wF + g bits de poidsfort, sa partie entière étant de 1 + wE bits.– La valeur de k est choisie de sorte que la soustraction entre Xfix et k · log 2 annule la partieentière ainsi que le bit de poids fort de la partie fractionnaire de X. Ainsi, on s’assure bienque −1

2 < Y < 12 .

– Les deux premiers multiplieurs étant des multiplieurs par des constantes, il est possibled’utiliser diverses techniques d’optimisations [Cha94, dDL00]. Ces techniques ne sont ce-pendant pas exploitées ici.– Si la multiplication finale entre eY1 et eY2 est représentée ici comme un produit suivi d’unesomme, selon l’architecture cible, une implémentation comme un unique multiplieur peutêtre plus intéressante [BT02]. De plus, comme il s’agit ici d’une multiplication par un en-semble de constantes, il est aussi possible de réaliser quelques optimisations sur cet opéra-teur [BT05].– La normalisation finale peut avoir à décaler la mantisse du résultat d’au plus un bit vers lagauche, comme détaillé par la suite.

4.3.3 Analyse d’erreur

De même que pour l’opérateur de logarithme, nous ne visons pas ici l’arrondi correct maisuniquement l’arrondi fidèle. Pour l’exponentielle présentée ici, l’analyse d’erreur a deux objec-tifs : nous permettre de minimiser le matériel nécessaire à la réduction de l’argument X ainsique garantir l’arrondi fidèle en tenant compte de toutes les erreurs d’approximation et d’arrondiinduites par l’opérateur.

Réduction d’argument

Comme l’entier k va devenir l’exposant (plus ou moins 1) du résultat final, il occupe wE + 1bits.Si l’étape de réduction d’argument était exacte, l’argument réduit Y serait compris dans l’in-

tervalle[−1

2 log 2, 12 log 2

], et on aurait donc eY ∈

[√2

2 ,√

2]. Dégrader la précision lors du calcul

de k revient alors à élargir l’intervalle couvert par Y . Comme nous l’avons vu plus haut, l’algo-rithme se souffre pas de voir l’intervalle de définition de Y étendu aux binades suivantes, soit]−1

2 , 12

[. On peut alors prouver que cette condition est vérifiée lorsque le calcul de k est effectué

avec seulement wE + 2 bits pour la constante 1log 2 et les wE + 4 bits de poids fort deXfix.

L’exponentielle eY sera alors comprise approximativement entre 0,6 et 1,7, ce qui signifie qu’ilfaudra parfois normaliser le résultat final en le décalant d’un bit sur la gauche et décrémenterl’exposant.

Arrondi fidèle

Dans la suite, toutes les erreurs entrant en jeu lors du calcul de eY sont exprimées en ulp durésultat, à savoir 1 ulp(eY ) = 2−wF−g. Cela nous permettra donc d’ajuster la finesse de cette erreurde sorte à garantir l’arrondi fidèle en faisant varier le nombre de bits de garde g.Il faut tout d’abord constater que la réduction d’argument elle-même n’est pas exacte. Ainsi,

Y est déjà possiblement entaché d’erreurs :– L’erreur de discrétisation commise sur la constante log 2, arrondie au plus proche avec wE +

wF + g bits de précision. Cette erreur étant ensuite multipliée par k, l’erreur ainsi commisesur Y est de 1

2 ulp.


– Si Xfix est exact lorsque EX − E0 ≥ 0, ce n’est pas le cas pour les exposants négatifs. Latroncature de la mantisse ainsi décalée sur la droite induit une erreur de 1 ulp.

– Enfin, après la soustraction finale, Y est a son tour tronqué à wF + g bits de précision, soitaussi une erreur de 1 ulp.

Ainsi, dans le pire des cas, l’erreur sur Y est de 52 ulp. Considérons alors les calculs suivants

utilisant Y :– La table pour eY1 contenant des valeurs arrondies au plus proche, l’erreur commise y esttoujours d’au plus 1

2 ulp.– Du fait de l’utilisation de la méthode HOTBM pour évaluer la fonction f(Y2), on ne peutgarantir qu’un arrondi fidèle du résultat, ce qui représente une erreur de 1 ulp. On n’a pasà tenir compte ici de l’erreur sur Y car seuls les bits de poids fort de Y2 servent à adressercette table. Par contre, en tronquant Y2 à ces quelques bits de poids fort, on commet aussiune erreur de 1 ulp qui vient s’ajouter à l’erreur d’évaluation précédente pour un total de2 ulp.

– Lors de l’addition de Y2 et de f(Y2), leurs erreurs respectives s’ajoutent, ce qui nous donnealors 9

2 ulp.– Cette erreur est ensuite multipliée par eY1 lors du produit suivant. Par contre, comme Y2 +

f(Y2) = eY2 − 1 est de l’ordre de 2−p, on ne tient pas compte de l’erreur de 12 ulp portée

par eY1 dans ce produit. Enfin, comme eY1 < 1,7, on a une erreur totale propagée par lemultiplieur bornée par 8 ulp.

– Le résultat du multiplieur est alors tronqué à wF + g bits de précision, ce qui rajoute 1 ulp àl’erreur totale.

– Enfin, l’addition finale avec la valeur de eY1 issue de la première table nous donne une erreurtotale de 19

2 ulp sur eY .Comme le résultat peut finalement être décalé d’un bit vers la gauche par l’étape de renorma-

lisation (multipliant ainsi par deux l’erreur commise), avant d’être arrondi à la précision finale. Eninjectant ainsi cette erreur totale dans la contrainte garantissant l’arrondi fidèle, on trouve ainsipour g la valeur minimale de 5 bits de garde.En reprenant cette analyse d’erreur et en remplaçant les troncatures par des arrondis au plus

proche, on pourrait probablement gagner un bit sur g, mais cela risquerait d’augmenter sensible-ment le chemin critique de l’opérateur.De même que pour l’opérateur pour le logarithme, nous avons testé exhaustivement toute

cette famille d’opérateurs pour les différents couples de paramètres (wE , wF ) jusqu’à la simpleprécision (wE , wF ) = (8, 23) grâce à la carte de développement Celoxica RC1000-PP. Ces simula-tions ont ainsi permis de vérifier la validité de notre analyse d’erreur : tous les résultats sont bienun arrondi fidèle de la valeur théorique, voire un arrondi correct dans plus de 75% des cas.

4.3.4 Résultats

La figure 4.6 et la table 4.3 présentent des estimations de surface et de délai pour l’opérateurde la fonction exponentielle pour divers paramètres wE et wF .La figure 4.7 compare ces résultat selon l’utilisation ou non des petits multiplieurs 18× 18 bits

présents sur certains modèles de FPGA. Là encore, on peut constater que près de la moitié de lasurface de l’opérateur est utilisée par des multiplieurs et qu’il est donc possible d’économiser cescellules logiques en implémentant ces multiplieurs grâce à des opérateurs dédiés sur les FPGAqui en disposent.La figure 4.8 compare quant à elle les versions combinatoire et pipelinée de l’opérateur pour

la fonction exponentielle. De même que pour les autres opérateurs de FPLibrary, cet opérateur estpipeliné à 100 MHz sur le FPGA cible XC2V1000-4. Ce support du pipeline se fait au prix d’unsurcoût en surface d’un peu plus d’une centaine de slices pour la simple précision. Par contre, le


34

56

78 6 8 10 12 14 16 18 20 22

0

250

500

750

1000

wE

wF

Surface (en slices)

(a) Surface en fonction de wE et wF .

34

56

78 6 8 10 12 14 16 18 20 22

50

70

90

wE

wF

Délai (en ns)

(b) Délai en fonction de wE et wF .

0

200

400

600

800

1000

6 8 10 12 14 16 18 20 22

4%

8%

12%

16%



(c) Surface en fonction de wF , avec wE = 8 bits.

60

70

80

90

100

6 8 10 12 14 16 18 20 22


Délai (en ns)

(d) Délai en fonction dewF , avec wE = 8 bits.

Figure 4.6 Caractéristiques en surface (à gauche) et en délai (à droite) de l’opérateur pour l’expo-nentielle en virgule flottante.

Précision Multiplieurs Surface Délai(wE , wF ) (slices % mults) (ns)

(3, 6) logique 143 (2%) – 5518 × 18 67 (1%) 3 48

(5, 10) logique 269 (5%) – 7218 × 18 130 (2%) 4 62

(6, 13) logique 364 (7%) – 7818 × 18 188 (3%) 5 73

(7, 16) logique 500 (9%) – 8018 × 18 269 (5%) 5 81

(8, 23) logique 938 (18%) – 9718 × 18 512 (10%) 9 96

Table 4.3 Surface et délai de l’opérateur pour l’exponentielle pour diverses précisions.

pipeline est ici relativement profond (15 cycles en simple précision) par rapport à la longueur duchemin critique de la version combinatoire, et l’on peut ainsi supposer que de petites optimisa-tions permettraient sûrement de gagner quelques cycles.De même que pour le logarithme, le tableau 4.4 présente les performances comparées de notre

opérateur face à la fonction équivalente en simple précision sur un Intel Xeon à 2,4 GHz. La fonc-tion logicielle est ici aussi issue de la libc GNU, qui utilise sur cette architecture l’instructionmicro-codée f2xm1. Encore une fois, on peut constater que le pipeline purement séquentiel denotre opérateur permet d’atteindre des débits plus élevés que le processeur généraliste.


0

200

400

600

800

1000

6 8 10 12 14 16 18 20 222

4

6

8

10


Surface (en slices) Multiplieurs 18 × 18

Mults en logiqueMults 18 × 18 (slices)Mults 18 × 18 (mults)


60

70

80

90

100

6 8 10 12 14 16 18 20 22


Délai (en ns)

Mults en logiqueMults 18 × 18

(b) Délai en fonction dewF , avec wE = 8 bits.

Figure 4.7 Caractéristiques comparées en surface (à gauche) et en délai (à droite) de l’opérateurselon l’utilisation ou non des petits multiplieurs 18 × 18.

0

200

400

600

800

1000

6 8 10 12 14 16 18 20 22

10%

20%





60

70

80

90

100

6 8 10 12 14 16 18 20 22

12

13

14

15

16




(b) Délai en fonction de wF , avec wE = 8 bits.

Figure 4.8 Caractéristiques comparées en surface (à gauche) et en délai (à droite) de l’opérateurentre versions combinatoire et pipelinée.

Cible Cycles Délai (ns) Débit (106 op/s)Intel Xeon à 2,4 GHz 308 128 8

FPGA Virtex-II à 100MHz 15 85 100

Table 4.4 Performances comparées de l’opérateur avec un processeur Intel Xeon, en simple préci-sion.

Enfin, le seul autre travail similaire présent dans la littérature, réalisé par Doss et Riley [DR04],décrit un opérateur pour le calcul de l’exponentielle en simple précision. Cet opérateur occupe5564 slices et calcule son résultat en 74 cycles à 85 MHz sur un FPGA Virtex-II XC2V4000-5 (lé-gèrement supérieur à celui utilisé pour nos estimations de performance). L’avantage de notreapproche apparaît ainsi clairement : là où Doss et Riley ont porté directement sur le FPGA unalgorithme logiciel effectuant tous ses calculs intermédiaires en virgule flottante, nous cherchonsà nous débarrasser le plus rapidement possible de cette virgule flottante pour effectuer tous lescalculs internes en virgule fixe, pour laquelle les opérateurs sont bien plus simples et compacts.


4.4 Sinus et cosinus


Réduction d’argument pour les angles en radian

Le problème de la réduction d’argument trigonométrique consiste à ramener un nombre envirgule flottante X, qui peut être possiblement très grand, dans l’intervalle

[−π

4 , π4

], en calculant

un entier k et un nombre réel α tels que :

α = X − k · π

2∈[−π

4,π

4

].

Une fois cette réduction d’argument effectuée, le sinus et le cosinus du nombre de départ Xsont déduits du sinus et du cosinus de l’argument réduit α grâce aux identités trigonométriquesdonnées par la figure 4.9. Il faut y ajouter que l’on se ramène toujours à α ∈

[0, π

4

]par simple

changement de signe : {sin(−α) = − sin(α), et

cos(−α) = cos(α).

1

02

3

α

Quadrant Reconstruction Quadrant Reconstruction

0

{sin(X) = sin(α)

cos(X) = cos(α)2

{sin(X) = − sin(α)

cos(X) = − cos(α)

1

{sin(X) = cos(α)

cos(X) = − sin(α)3

{sin(X) = − cos(α)

cos(X) = sin(α)

Figure 4.9 Réduction d’argument trigonométrique par quadrants.

Ici, k est défini comme l’arrondi deX× 2πà l’entier le plus proche. Une variante, employée dans

les implémentations logicielles de Markstein sur IA-64 [Mar00], utilise comme argument réduit Yla partie fractionnaire de X × 4

π, et évalue ensuite sin

(π4 Y)et cos

(π4 Y). De notre point de vue,

cette variante présente deux avantages. D’une part, il y a une soustraction et une multiplicationen moins par rapport au calcul de α = X − k · π

2 . D’autre part, nous évaluons le sinus et le cosinusde l’argument réduit par la méthode à base de tables HOTBM présentée au chapitre 2, qui est plusfacile à mettre en œuvre pour un argument réduit dans l’intervalle

[−1

2 , 12

]que dans un intervalle

comme[−π

4 , π4

]. L’inconvénient principal de cette variante est que le développement limité de

sin(

π4 Y), dont on a besoin lors de l’évaluation proprement dite, est légèrement moins simple que

celui de sin(α).La question difficile est de calculer X × 4

πavec une précision suffisante. Naturellement, on va

utiliser un multiplieur par la constante 4π, mais pour de très grandes valeurs de X, on a besoin

d’une grande précision de cette constante, puisque l’on ne veut garder que la partie fractionnairedu résultat. On peut toutefois remarquer qu’on n’a pas besoin de calculer entièrement la partieentière k deX × 4

π: on a besoin juste des trois bits de poids faible de k pour déterminer l’octant de

l’argument réduit, et donc toute l’information nécessaire à notre réduction d’argument (la valeurabsolue et le signe de Y ). Les bits de poids plus forts n’ont pas besoin d’être calculés, puisqu’ilscorrespondent à des multiples entiers de la période. CommeX est un nombre en virgule flottante,c’est sa mantisse qui seramultipliée par 4

π, et son exposant peut être utilisé pour tronquer à gauche

la constante et ne garder que les bits dont on a besoin pour obtenir trois bits entiers du produit.Cette idée est due à Payne et Hanek [PH83] et a été popularisée par Ng [Ng92].

4.4 Sinus et cosinus 111

Combien de bits de 4πdoivent être multipliés par la mantisse de X ? Sans parler des bits de

garde, qui seront déterminés par l’analyse d’erreur et par le paragraphe suivant, il faut multiplierpar la mantisse de X au moins 2wF bits de 4

π. En effet, les wF bits de poids forts du produit ne

seront pas valides puisque calculés au moyen d’une constante 4πtronquée.

Il reste encore une subtilité. La partie fractionnaire Y deX × 4πpeut s’approcher extrêmement

près de zéro pour certaines valeurs de X. Ainsi, il peut arriver que Y commence par une longuesuite de zéros. En virgule fixe ce ne serait pas un souci, mais si l’on veut calculer un sinus envirgule flottante dont tous les bits sont significatifs, il faut commencer par assurer que tous les bitsde Y le soient. Pour cela, il faut ajouter encore gK bits de garde à la constante 4

π. Un algorithme

dû à Kahan et Douglas [Mul05a] permet de calculer, pour un domaine flottant donné, quelle est laplus petite valeur possible de Y , et donc la valeur de gK . On constate expérimentalement que gK

est de l’ordre de wF .Finalement, la réduction d’argument trigonométrique nécessite :– de stocker la constante 4

πsur un nombre de bits de l’ordre de 2wE−1 + 3wF ,

– du matériel pour extraire de l’ordre de 3wF bits de cette constante,– un multiplieur rectangulaire de l’ordre de wF × 3wF bits,– un décaleur pour renormaliser éventuellement le résultat.Le coût en matériel est donc élevé. Le coût en temps peut toutefois être réduit par une ar-

chitecture à double chemin de calcul (ou dual path, comme on en trouve dans les additionneursflottants), présentée ci-dessous.D’autres réductions d’argument sont présentées dans [Mul05a]. La technique de Cody etWaite

[CW80] n’est utile que pour les petits arguments dans une approche logicielle utilisant des opéra-teurs flottants. Les variantes de la réduction d’argument modulaire [DMMM95, VLG06] ont aussiété considérées, mais elles s’avèrent plus coûteuses que l’approche présentée ci-dessus. Plus pré-cisément, il s’agit d’approches itératives qui se prêtent très mal à une implémentation pipelinée.

Fonctions trigonométriques à réduction d’argument simple

On l’a vu, la difficulté de la réduction d’argument pour les fonctions en radian tient à ce que laconstante 4

πest irrationnelle et qu’on a besoin d’un grand nombre de bits de cette constante. Dès

lors que la constante est rationnelle (angles en degrés ou sin(πX)), le problème devient beaucoupplus simple. Par exemple, pour sin(πX), la réduction d’argument consiste simplement à décompo-serX en sa partie entière et sa partie fractionnaire. Comme X est un nombre en virgule flottante,cela coûte tout de même un décalage, mais l’avantage est que cette opération est toujours exacte :la précision intermédiaire requise reste de l’ordre de wF bits, pas plus.

Seconde réduction d’argument

Il est possible d’utiliser une seconde réduction d’argument tabulant des valeurs de sinus etcosinus en des points intermédiaires de l’intervalle

[0, π

4

]. En découpant Y en Y1 et Y2, avec Y1 les

p bits de poids fort de Y , on peut alors utiliser les identités suivantes, dans lesquelles les valeursen Y1 sont directement tabulées :

{sin(

π4 Y)

= sin(

π4 Y1 + π

4 Y2

)= cos

(π4 Y1

)· sin

(π4 Y2

)+ sin

(π4 Y1

)· cos

(π4 Y2

), et

cos(

π4 Y)

= cos(

π4 Y1 + π

4 Y2

)= cos

(π4 Y1

)· cos

(π4 Y2

)− sin

(π4 Y1

)· sin

(π4 Y2

).

Cette idée a été explorée mais non finalisée. La conclusion est toutefois que la quantité decalculs nécessaires ne se justifie pas pour des précisions allant jusqu’à la simple précision. Lesopérateurs sont en principe plus petits, mais l’analyse d’erreur montre qu’il faut rajouter 7 bits degarde à la plupart des chemins de calculs, ce qui annule l’intérêt de cette méthode.


Par contre, cette seconde réduction d’argument devrait rendre l’approche par table viable jus-qu’à la double précision, ce que nous comptons explorer dans un avenir proche.

Architecture duale sinus et cosinus

Si la réduction d’argument est coûteuse, il est possible de la partager dans le cas fréquent oùl’on doit calculer le sinus et le cosinus d’un même angle (par exemple pour calculer une rota-tion). En fait, telle que présentée ci-dessus, la réduction d’argument oblige l’opérateur à calculertoujours en parallèle le sinus et le cosinus de l’angle, puisque le résultat final sera l’un ou l’autresuivant le quadrant dans lequel tombeX.Si l’on veut un opérateur plus économique qui ne produise qu’une des deux fonctions, il faut

remplacer la constante π4 par

π2 dans la réduction d’argument. Nous verrons par la suite que le

bénéfice est maigre.

4.4.2 Implémentation de référence

Vue d’ensemble

Cette implémentation est compatible avec l’esprit de la norme IEEE 754 et des autres opéra-teurs de FPLibrary, ainsi qu’avec les pratiques en usage en logiciel : elle implémente une réductiond’argument précise pour obtenir l’arrondi fidèle du résultat pour tout nombre en entrée.L’architecture générale de cette implémentation est donnée par la figure 4.10. L’architecture

spécifique à la réduction d’argument, présentée plus en détail dans la section 4.4.2, est représentéefigure 4.11. Demême, les architectures détaillées pour le calcul du sinus et du cosinus sont donnéesfigures 4.12(a) et 4.12(b) respectivement.L’étage de reconstruction quant à lui se contente d’appliquer les identités trigonométriques

présentées figure 4.9 pour retrouver sin X et cos X à partir de sin(

π4 Y)et cos

(π4 Y), en fonction de

l’octant indiqué par k. Le signe deX est aussi pris en compte dans le cas du sinus.Enfin, une petite unité dédiée permet de traiter les cas exceptionnels, comme par exemple le

calcul de sin(+∞) qui renverra NaN.

Réduction d’argument à double chemin

Il faut décrire plus en détail la sortie de la réduction d’argument. On veut donc pouvoir cal-culer sin

(π4 Y)et cos

(π4 Y), tous deux en virgule flottante. Le cosinus sera compris entre

√2

2 et 1,donc son exposant est déjà connu. Par conséquent, pour le calculer, on peut se contenter d’unereprésentation de Y en virgule fixe, notée Yfix. Par contre, le sinus peut s’approcher très près dezéro, donc il faut avoir également une représentation flottante de Y , dénotée (EY ,MY ) (représen-tant respectivement exposant et mantisse normalisée de Y ). Cette forme en virgule flottante estobtenue dans le cas général par un compteur de zéros de poids forts (LZC, pour Leading-ZeroCounter) couplé à un décaleur.Il y a un cas particulier lorsqueX, l’argument de départ, est proche de zéro (en pratique x < 1

2 ).Dans ce cas on peut déduire directement l’exposant de Y de celui deX, puisque les deux nombressont dans un rapport constant de 4

π(il faut au plus une petite normalisation par un décalage de un

bit). Donc n’a pas besoin de décaler la constante 4πet on obtientMY et EY rapidement. Par contre,

on doit calculer Yfix par un décalage variable deMY suivant l’exposant EY .On obtient ainsi deux chemins de calcul exclusifs visibles sur la figure 4.11 : le chemin close

pour les valeurs deX proches de zéro, qui calcule Yfix à partir de (EY ,MY ), et le chemin far, pourles valeurs deX distantes de zéro, qui calcule (EY ,MY ) à partir de Yfix. La sélection entre ces deuxchemins se fait simplement à partir de la valeur de l’exposant EX .


rédu tion d'argumentk

wE + wF + 3

sinus osinus

gestion des ex eptionswE + wF + 3wE + wF + 3

3 wEwF + g wF + g + 1

wE + wF + 1 wE + wF + 1

re onstru tionwE + wF wE + wF

2 1 wE wF

X

S ≈ sin X C ≈ cos X

sin(

π4Y

)cos

(π4Y

)

MYEYYfix

FXEXexnX SX

Figure 4.10 Architecture générale de l’opérateur dual sinus/cosinus en virgule flottante.

Évaluations par tables de sin(π

4Y)et cos

(π

4Y)

On utilise ici aussi la méthode HOTBM présentée dans le chapitre 2, qui permet d’obtenir desimplémentations très compactes de fonctions continues en virgule fixe.Pour le cosinus, on peut utiliser cette méthode directement puisque, comme cela a déjà été

précisé, l’exposant du résultat est connu, autrement dit le résultat est en virgule fixe. On économisetoutefois le stockage du premier bit, qui vaut toujours 1, en choisissant d’évaluer la fonction fcos

suivante :fcos(Yfix) = 1 − cos

(π

4Yfix

).

Le sinus, par contre, peut s’approcher près de zéro, et donc aura un exposant variable. Pour seramener à une fonction en virgule fixe, on utilise l’égalité suivante :

sin(π

4Y)

= Y ×sin(π

4Y)

Y.

L’intérêt est que le terme de droite du produit peut alors être tabulé en virgule fixe par HOTBM,


4

π

wF1

3 + wF + g + gK

wF + g + gK3

wE

3 + 2wF + g + gK

2 + wF + g

wE

E0 − 1

E

1 + wF + g

wF + g

kfar

1 + wF + g

LZCwE

wF + g

3

k

0

wF + g wE 1 + wF + g

EX FX

Yfix EY MY

M farY

M closeY

EcloseY

±1

far path

path

close

far/close

Y close

EfarY

Y closefix

Y farfix

Y far

Figure 4.11 Architecture détaillée de la réduction d’argument dual path.

car son développement de Taylor est :

sin(π

4Y)

Y=

π

4+ O(Y 2).

L’exposant du résultat est quant à lui déterminé par l’exposant de Y , à savoir EY . On choisitdonc de tabuler la fonction fsin suivante :

fsin(Yfix) =π

4−

sin(π

4Yfix

)

Yfix.

Lamultiplication finale par Y est unemultiplication d’un nombre en virgule flottante (EY ,MY )par un nombre en virgule fixe, et donc relativement simple.Les deux architectures correspondantes sont présentées figures 4.12(a) et 4.12(b).

Analyse d’erreur

De même que pour les opérateurs précédents, seul l’arrondi fidèle est garanti ici. L’erreur ab-solue commise sur la mantisse est ainsi bornée par 2−wF .


HOTBMwF + g

wF + g

π

4

wF + g + 3

wF + g + 3

wE

arrondi / renormalisationwE + wF

Yfix

1 + wF + g

MY EY

fsin(Yfix)

sin(π

4Y)

(a) Sinus.

HOTBMwF + g

wF + g

arrondi / renormalisationwE + wF

1

wF + g + 2

wF + g + 2

Yfix

fcos(Yfix)

cos(π

4Y)

(b) Cosinus.

Figure 4.12 Architectures détaillées de l’évaluation du sinus (à gauche) et du cosinus (à droite).

Il est de même possible de suivre précisément les erreurs commises par l’opérateur depuis laréduction d’argument jusqu’à l’évaluation de sin

(π4 Y)et cos

(π4 Y). Ce calcul, similaire aux précé-

dents, permet ainsi d’obtenir la contrainte sur g d’au moins 2 bits de garde pour garantir l’arrondifidèle.

4.4.3 Implémentations dégradées

Devant la surface relativement importante occupée par l’opérateur dual sinus/cosinus (voirsection 4.4.4), nous avons exploré diverses alternatives à cet opérateur, pour proposer plusieurscompromis entre précision, surface et latence.

Opérateur seul

Certaines applications n’ont besoin de calculer que des sinus mais pas de cosinus (et récipro-quement). Pour gagner un peu de matériel, nous proposons donc une version de notre opérateurne calculant que le sinus deX.Pour éviter d’avoir à calculer de cosinus, la réduction d’argument doit se faire sur les qua-

drants et non les octants du cercle unité. Ainsi, l’angle réduit α sera dans l’intervalle[0, π

2

], deux

fois plus large que pour l’opérateur dual sinus/cosinus.La réduction d’argument est ici quasiment identique à la réduction d’argument de l’opérateur

dual, si ce n’est la constante qui est 2πau lieu de 4

π. Cela ne va donc pas permettre d’économiser

de matériel : le gros multiplieur wF × 3wF bits est toujours nécessaire.Quant à l’évaluation de la fonction fsin(Yfix), puisqu’elle s’effectue sur un intervalle deux fois

plus large, l’opérateur HOTBM va occuper plus de place.Ainsi, le gain de la suppression de l’opérateur pour fcos(Yfix) ne peut être que très léger, comme

le confirment les résultats présentés section 4.4.4.


Une implémentation avec sortie en virgule fixe

Une grande part de la surface et du délai de l’opérateur est due au multiplieur utilisé pour laréduction d’argument. En relâchant les contraintes de précision, on peut diminuer le nombre debits de la constante 4

πà prendre en compte, et ainsi directement diminuer la taille et la latence de

ce multiplieur.Considérer un opérateur qui fournirait sa sortie en virgule fixe nous a semblé une option inté-

ressante, puisqu’elle permettait justement d’éliminer les gK bits de garde supplémentaires néces-saires pour la constante, mais aussi simplifiait le calcul de sin

(π4 Y). En effet, n’ayant plus besoin

de renormaliser le résultat, on peut évaluer la fonction sinus directement à l’aide de HOTBM, sanspasser par la fonction fsin. On économise donc alors aussi la multiplication parMY .Le gain est effectivement substantiel, comme le montrent les résultats présentés plus loin.

Fonctions trigonométriques en degrés et en πX

Comme déjà mentionné précédemment, les fonctions trigonométriques en radians ne sont pasnécessaires pour de nombreux programmes, qui pourraient très bien s’accommoder de fonctionstrigonométriques travaillant en degrés ou en multiples de π. De telles fonctions sont de plus déjàenvisagées pour figurer dans la future révision de la norme IEEE 754 [IEE06], ce qui constitue unejustification supplémentaire pour s’y intéresser.Nous avons donc étudié de près la réalisation d’un opérateur dual calculant sin(πX) et cos(πX).

L’intérêt d’un tel opérateur est de simplifier grandement le processus de réduction d’argument,en épargnant le calcul coûteux du produitX× 4

π. De plus, Y étant calculé exactement, cela permet

de gagner un bit de garde pour l’évaluation des fonctions fsin et fcos.Encore une fois, les résultats obtenus sont très intéressants et encouragent à poursuivre le

développement aussi sur cette voie.

4.4.4 Résultats

Les estimations de surface et de délai pour les différentes versions des opérateurs trigonomé-triques sont présentées dans la table 4.5.Nous présentons là aussi ces estimations pour les deux alternatives d’implémentation desmul-

tiplieurs : sur la logique du FPGA ou sur les petits multiplieurs 18 × 18 dédiés. Par contre, le pi-peline des opérateurs n’étant pas achevé, il est pas présenté ici. Les estimations de délai sur lesversions combinatoires permettent déjà de se faire une idée de la profondeur qu’auront ces opé-rateurs pipelinés, à savoir de 10 cycles pour les plus petits à entre 15 et 18 cycles pour les plusgros.La seule autre référence à des travaux similaires dans la littérature est [OHDP03], dans le-

quel les auteurs décrivent divers opérateurs pour l’évaluation de fonctions trigonométriques envirgule flottante sur FPGA. Les algorithmes qu’ils utilisent sont relativement simples (tabulationdirecte, CORDIC ou approximation linéaire) et reposent sur des opérateurs flottants. Cependant,leur implémentation ne fait pas de réduction d’argument, ce qui rend impossible la comparaisonobjective de ces travaux avec les nôtres.

4.5 Conclusion

4.5.1 Contribution

Les trois opérateurs présentés dans ce chapitre forment ainsi une première bibliothèque defonctions élémentaires en virgule flottante pour FPGA, intégrée à FPLibrary. Ces opérateurs sont

4.5 Conclusion 117

Dual sinus/cosinus Sinus seulPrécision Multiplieurs Surface Délai Surface Délai(wE , wF ) (slices % mults) (ns) (slices % mults) (ns)(5, 10) logique 803 (15%) – 69 709 (13%) – 70

18 × 18 424 (8%) 7 61 310 (6%) 6 62

(6, 13) logique 1159 (22%) – 86 1027 (20%) – 8618 × 18 537 (10%) 7 76 474 (9%) 6 79

(7, 16) logique 1652 (32%) – 91 1428 (27%) – 9218 × 18 816 (15%) 10 87 609 (11%) 10 83

(7, 20) logique 2549 (49%) – 99 2050 (40%) – 10118 × 18 1372 (26%) 17 96 979 (19%) 15 92

(8, 23) logique 3320 (64%) – 109 2659 (51%) – 10518 × 18 1700 (33%) 19 99 1279 (24%) 16 100

Sinus/cosinus en virgule fixe Sinus/cosinus en πxPrécision Multiplieurs Surface Délai Surface Délai(wE , wF ) (slices % mults) (ns) (slices % mults) (ns)(5, 10) logique 376 (7%) – 57 363 (7%) – 58

18 × 18 241 (4%) 4 51 244 (4%) 3 46

(6, 13) logique 642 (12%) – 63 641 (12%) – 6118 × 18 380 (7%) 4 58 462 (9%) 3 61

(7, 16) logique 923 (18%) – 72 865 (16%) – 7318 × 18 528 (10%) 5 70 559 (10%) 4 69

(7, 20) logique 1620 (31%) – 82 1531 (29%) – 8418 × 18 973 (19%) 9 75 1005 (19%) 8 76

(8, 23) logique 2203 (43%) – 88 2081 (40%) – 8918 × 18 1294 (25%) 12 80 1365 (25%) 10 85

Table 4.5 Surface et délai des différentes variantes d’opérateurs trigonométriques pour diversesprécisions.

de qualité, du point de vue de la précision des calculs, maîtrisée grâce à une analyse d’erreur fineet rigoureuse et validée par des tests exhaustifs, mais aussi du point de vue des performances,témoignant de l’adéquation des algorithmes développés avec les spécificités architecturales desFPGA.De plus, si les opérateurs trigonométriques dans leur implémentation de référence sont coû-

teux, nous proposons aussi diverses solutions pour relâcher les contraintes de précision, couvrantainsi un compromis plus vaste entre coût, performance et précision des calculs.

4.5.2 Perspectives

Les résultats très encourageants obtenus nous poussent donc à poursuivre le développementde tels opérateurs pour FPLibrary. Vers des opérateurs pour d’autres fonctions, bien sûr, maisaussi vers l’extension des opérateurs existants à la double précision (wE , wF ) = (11, 52), puisqueles applications actuelles sur FPGA manipulent déjà des nombres avec de telles précisions [dD05,DVKG05].Les travaux dans cette direction sont déjà bien avancés, et nous comptons ainsi finaliser l’inté-

gration dans FPLibrary d’opérateurs pour le calcul du logarithme et de l’exponentielle en virguleflottante jusqu’à la double précision [DdDP06]. Ces opérateurs ne sont d’ailleurs pas beaucoupplus coûteux en surface que les opérateurs pour la simple précision, car ils utilisent des algo-rithmes itératifs comme ceux de Wong et Goto [WG94], sensiblement plus lents mais bien plus


petits que les méthodes directes à base de tables pour l’évaluation en virgule fixe des fonctions.Nous comptons aussi étendre rapidement ces résultats aux fonctions trigonométriques sinus etcosinus.Enfin, il faut bien voir qu’ici l’offre précède la demande : pour l’instant très peu d’applications

implémentées sur FPGA requièrent des opérateurs pour les fonctions élémentaires en virgule flot-tante. Cependant, nous pensons que la publication de ces opérateurs va justement favoriser l’ap-parition de telles applications. La direction que devront prendre les futurs développements sur cesujet sera bien entendu conditionnée par les retours des utilisateurs de notre bibliothèque.

Conclusion

Les différents travaux présentés dans cette thèse concourent tous à l’implémentation sur FPGAd’opérateurs arithmétiques sur les nombres réels, dans le but d’offrir à la communauté des outilssimples et facilement adaptables permettant de porter n’importe quel algorithme fortement cal-culatoire sur ces circuits reconfigurables.Ainsi, en ce qui concerne la virgule fixe, nous avons développé la méthode HOTBM pour

l’évaluation de fonctions élémentaires. Il s’agit d’une méthode générale et utilisable pour la plu-part des fonctions élémentaires et compositions de celles-ci. Cetteméthode s’est révélée êtremoinscoûteuse à précision équivalente que les autres méthodes à base de table, permettant d’atteindredes précisions jusqu’à 32 bits. Développée avec un souci particulier de maintenir une flexibilitémaximale au niveau des choix architecturaux, cette méthode intègre donc des dizaines de para-mètres allant du degré de l’approximation polynomiale au nombre de tables utilisées en passantpar le découpage de l’opérande. La motivation derrière cette flexibilité était de permettre d’adap-ter finement les opérateurs aux spécificités de chaque application, en explorant le compromis entreprécision, coût et performance au cas par cas des applications. Pour valider cette méthode maissurtout dans le but de faciliter la navigation dans cet espace des paramètres, nous avons aussidéveloppé un générateur d’opérateurs, capable de produire l’opérateur correspondant à un jeuparticulier de paramètres. Cet outil peut aussi explorer automatiquement un sous-ensemble deparamètres et ainsi, grâce à des heuristiques ad-hoc, rechercher des solutions optimales par rap-port à une fonction de coût donnée. Enfin, développée conjointement à cette méthode HOTBM,une analyse d’erreur rigoureuse a été présentée. Cette analyse d’erreur, prenant en compte tousles paramètres de la méthode, offre ainsi une garantie sur la précision finale des valeurs calculéespar l’opérateur. Elle permet aussi d’étudier précisément, pour chaque table, chaque additionneuret chaque multiplieur, sa contribution à l’erreur globale de l’opérateur. Il est alors possible d’ex-ploiter cette information pour optimiser la largeur des chemins de données de cet opérateur enéquilibrant au mieux la précision de ses divers composants par rapport à la précision globale.Concernant les nombres réels à plus grande dynamique, nous avons présenté dans cette thèse

FPLibrary, une bibliothèque d’opérateurs de base supportant aussi bien la virgule flottante (jus-qu’à la double précision) et le système logarithmique (jusqu’à la simple précision). Si ces opé-rateurs sont moins flexibles que ceux proposés par la méthode HOTBM, ils sont tout de mêmeparamétrés en termes de dynamique et de précision des nombres, et décrits de manière suffisam-ment générique pour pouvoir s’adapter aux spécificités architecturales des principaux modèlesde FPGA. Antérieure aux autres travaux présentés ici, FPLibrary était notre coup d’essai vers ledéveloppement d’opérateurs paramétrables et flexibles, adaptables aux divers besoins des appli-cations. C’est son succès immédiat qui nous a encouragés à poursuivre dans cette direction.Enfin, profitant de nos expériences cumulées des fonctions élémentaires en virgule fixe de

HOTBM et des opérateurs de base en virgule flottante de FPLibrary, nous avons développé troisopérateurs pour les fonctions élémentaire en virgule flottante. Ces opérateurs font désormais par-tie intégrante de FPLibrary. Étant eux aussi paramétrés en termes de dynamique et de précisiondes nombres, ils sont de la mêmemanière capables de s’adapter aux besoins particuliers de chaque

120 Conclusion

application. De nouveaux algorithmes d’évaluation ont été mis au point spécifiquement pour cesopérateurs, de sorte à assurer la précision de leurs résultats sans pénaliser leurs performances. En-fin, ces opérateurs ont aussi fait l’objet d’analyses d’erreurs rigoureuses, permettant comme pourHOTBM de garantir l’arrondi fidèle des fonctions ainsi que d’optimiser les chemins de données.De ces trois travaux se dégagent ainsi des principes directeurs que nous souhaitons étendre et

promouvoir sous la forme d’une méthodologie générale pour la conception d’opérateurs arithmé-tiques sur les nombres réels. Les principes retenus ici sont avant tout la flexibilité et la paramétra-bilité des opérateurs, ainsi que l’analyse systématique et rigoureuse de l’erreur.Le premier principe, déjà bien respecté par la méthode HOTBM et partiellement intégré dans

FPLibrary, permet de rendre les opérateurs concernés adaptables finement aux différentes appli-cations, proposant plusieurs solutions dans l’espace du compromis précision/coût/performance.Cela signifie donc offrir des opérateurs avec une précision ajustable mais aussi toute une gammed’algorithmes d’évaluation différents pour laisser un vaste choix, des opérateurs rapides et grosaux petits et lents. De plus, dans un souci de portabilité, étant données les disparités architectu-rales entre les différents modèles de FPGA ainsi que les technologies ASIC, il est toujours avan-tageux de disposer de plusieurs variantes d’un même opérateur pour pouvoir choisir la versionoptimale selon la technologie cible.Le second principe, appliqué avec succès à la méthode HOTBM ainsi qu’aux opérateurs de

FPLibrary, offre quant à lui un intérêt double. L’analyse d’erreur systématique permet tout d’abordde tirer parti d’un simple principe d’optimisation qui est de ne pas faire de calculs intermédiairesplus précis que le strict nécessaire à l’intérieur des opérateurs. Comme on a pu le voir sur lesdifférents opérateurs présentés ici, équilibrer les contributions d’erreur dans un opérateur permetainsi d’optimiser la largeur des chemins de données, et donc de réduire le coût en matériel et enlatence de cet opérateur. Mais l’avantage majeur de cette analyse d’erreur est de fournir une ga-rantie sur la qualité des calculs effectués par l’opérateur concerné. L’objectif étant ici de simplifierau maximum le portage d’algorithmes numériques logiciels vers une implémentation matérielle,il faut que les opérateurs aient des comportements en termes d’erreur proches de leurs équivalentslogiciels, ou tout du moins bien spécifiés et garantis.Cette méthodologie a certes un coût certain, qui rend plus long et difficile le développement

des opérateurs, mais le jeu en vaut bel et bien la chandelle. En sont ainsi témoins le gain en perfor-mance des opérateurs pour l’évaluation de fonctions élémentaires, ou encore la souplesse d’uti-lisation des opérateurs de base de FPLibrary confirmée par le succès de cette bibliothèque. Onretrouve aussi cette philosophie dans d’autres travaux actuels, comme par exemple l’outil Div-gen, un générateur de diviseurs entiers, supportant plusieurs algorithmes, plusieurs formats dereprésentation des nombres, plusieurs arrondis, etc... [MTVC05].Les perspectives soulevées par ces travaux sont par conséquent nombreuses. Au-delà des ob-

jectifs à court terme comme l’extension à la double précision des fonctions élémentaires de FPLi-brary, ou l’amélioration des heuristiques dans le générateur d’opérateurs de la méthode HOTBM,il s’agit surtout de généraliser et d’étendre l’application de cette méthodologie à nos travaux exis-tants et futurs.On peut donc tout d’abord envisager un rapprochement de HOTBM et de FPLibrary, puis-

qu’après tout les opérateurs décrits dans ces travaux restent orientés vers l’arithmétique réelle. Dela même manière que FPLibrary propose déjà des opérateurs pour la virgule flottante et le sys-tème logarithmique, lui ajouter un support pour la virgule fixe permettrait encore d’augmenter lacouverture du compromis précision/coût/performance auquel elle s’attaque déjà.De plus, comme on l’a déjà mentionné, les opérateurs de FPLibrary sont encore relativement

“rigides”, en ce sens qu’ils ne sont paramétrables qu’en termes de précision et de dynamiquedes nombres qu’ils manipulent. Il serait donc intéressant de développer plutôt des générateursd’opérateurs, comme pour HOTBM, pour laisser plus de liberté dans les choix architecturaux et

Conclusion 121

ainsi augmenter leur flexibilité.L’objectif à long terme vers lequel nous souhaitons faire tendre nos recherches est ainsi un

cadre commun pour l’implémentation d’algorithmes numériques en matériel, sur FPGA commesur ASIC, sans que l’utilisateur ait besoin de se préoccuper de questions arithmétiques et architec-turales. Cet objectif repose donc sur l’application systématique de la méthodologie proposée, pourgénéraliser la conception de générateurs d’opérateurs et non plus d’opérateurs simples commecela est encore le cas dans la littérature actuelle. Ce travail permettra alors de disposer d’une basecommune d’opérateurs flexibles, précis et capables de s’adapter finement aux besoins de chaqueapplication. Il s’agit aussi de développer conjointement des heuristiques permettant la rechercheparmi tous ces opérateurs des solutions optimales selon des fonctions de coût données, explorantainsi le vaste compromis entre système de représentation des nombres, précision, coût et perfor-mance.

Bibliographie

[ABCW92] Mark G. ARNOLD, Thomas A. BAILEY, John R. COWLES et Mark D. WINKEL : Ap-plying features of IEEE 754 to sign/logarithm arithmetic. IEEE Transactions on Com-puters, 41(8):1040–1050, août 1992.

[Act05] Actel Corporation, Mountain View, CA, USA. Axcelerator family FPGAs, décembre2005.

[AI85] ANSI et IEEE : ANSI/IEEE 754-1985, Standard for Binary Floating-Point Arithmetic.IEEE, New York, NY, USA, août 1985.

[Alt06a] Altera Corporation, San Jose, CA, USA. Stratix device family data sheet, janvier 2006.

[Alt06b] Altera Corporation, San Jose, CA, USA. Stratix II device family data sheet, août 2006.

[Beu03] Jean-Luc BEUCHAT : Fpga implementations of the RC6 block cipher. In P.Y.K.CHEUNG, G.A. CONSTANTINIDES et J.T. de SOUSA, éditeurs : Field-ProgrammableLogic and Applications : 13th International Conference, FPL 2003, numéro 2778 deLecture Notes in Computer Science, pages 101–110, Lisbon, Portugal, septembre2003. Springer-Verlag.

[BL02] Pavle BELANOVIC et Miriam LEESER : A library of parameterized floating-pointmodules and their use. In M. GLESNER, P. ZIPF et M. RENOVELL, éditeurs : Field-Programmable Logic and Applications : 12th International Conference, FPL 2002,numéro 2438 de Lecture Notes in Computer Science, pages 657–666, Montpellier,France, septembre 2002. Springer-Verlag.

[BMP+06] Andrey BOGDANOV, Marius C. MERTENS, Christof PAAR, Jan PELZL et Andy RUPP :A parallel hardware architecture for fast gaussian elimination over gf(2). InJ.M. ARNOLD et K.L. POCEK, éditeurs : 14th Annual IEEE Symposium on Field-Programmable Custom Computing Machines (FCCM’06), pages 237–248, Napa, CA,USA, avril 2006. IEEE Computer Society.

[BT02] Jean-Luc BEUCHAT et Arnaud TISSERAND : Small multiplier-based multiplicationand division operators for Virtex-II devices. In M. GLESNER, P. ZIPF et M. RE-NOVELL, éditeurs : Field-Programmable Logic and Applications : 12th InternationalConference, FPL 2002, numéro 2438 de Lecture Notes in Computer Science, pages513–522, Montpellier, France, septembre 2002. Springer-Verlag.

[BT05] Nicolas BOULLIS et Arnaud TISSERAND : Some optimizations of hardware multi-plication by constant matrices. IEEE Transactions on Computers, 54(10):1271–1282,octobre 2005.

[CCSK00] J. Nick COLEMAN, Ed I. CHESTER, Chris I. SOFTLEY et Jirí KADLEC : Arithmetic onthe european logarithmic microprocessor. IEEE Transactions on Computers, 49(7):702–715, juillet 2000.

[Cha94] Kenneth D. CHAPMAN : Fast integer multipliers fit in FPGAs. EDN, 39(9), mai 1994.

124 Bibliographie

[CO84] Charles W. CLENSHAW et Frank W. J. OLVER : Beyond floating point. Journal of theACM, 31(2):319–328, avril 1984.

[Cra05] Cray, Inc., Seattle, WA, USA. Cray XD1 datasheet, 2005.

[CW80] William J. CODY et William M. WAITE : Software Manual for the Elementary Func-tions. Prentice Hall, Englewood Cliffs, NJ, USA, juillet 1980.

[CWC01] Jun CAO, Belle W.Y. WEI et Jie CHENG : High-performance architectures for elemen-tary function generation. In N. BURGESS et L. CIMINIERA, éditeurs : Proceedings ofthe 15th IEEE Symposium on Computer Arithmetic (ARITH’15), pages 136–144, Vail,CO, USA, juin 2001. IEEE Computer Society.

[dD05] Michael DELORIMIER et André DEHON : Floating-point sparse matrix-vectormultiply for FPGAs. In 13th ACM/SIGDA International Symposium on Field-programmable Gate Arrays (FPGA’05), pages 75–85, Monterey, CA, USA, février2005. ACM Press.

[DdD03] Jérémie DETREY et Florent de DINECHIN : A VHDL library of LNS operators. In 37thAsilomar Conference on Signals, Systems & Computers, volume 2, pages 2227–2231,Pacific Grove, CA, USA, novembre 2003. IEEE Signal Processing Society.

[DdD04] Jérémie DETREY et Florent de DINECHIN : Second order function approximationusing a single multiplication on FPGAs. In J. BECKER, M. PLATZNER et S. VER-NALDE, éditeurs : Field-Programmable Logic and Applications : 14th InternationalConference, FPL 2004, numéro 3203 de Lecture Notes in Computer Science, pages221–230, Antwerp, Belgium, septembre 2004. Springer-Verlag.

[DdDM02] David DEFOUR, Florent de DINECHIN et Jean-Michel MULLER : A new scheme fortable-based evaluation of functions. In 36th Asilomar Conference on Signals, Sys-tems & Computers, volume 2, pages 1608–1612, Pacific Grove, CA, USA, novembre2002. IEEE Signal Processing Society.

[DdDP06] Jérémie DETREY, Florent de DINECHIN et Xavier PUJOL : Return of the hardwarefloating-point elementary function. Research Report RR2006-45, Laboratoire de l’In-formatique du Parallélisme, École Normale Supérieure de Lyon, Lyon, France, no-vembre 2006.

[dDL00] Florent de DINECHIN et Vincent LEFÈVRE : Constant multipliers for FPGAs. InH.R. ARABNIA, éditeur : Proceedings of the International Conference on Parallel andDistributed Processing Techniques and Applications (PDPTA’00), volume 1, pages167–173, Las Vegas, NV, USA, juin 2000. CSREA Press.

[dDT05] Florent de DINECHIN et Arnaud TISSERAND : Multipartite table methods. IEEETransactions on Computers, 54(3):319–330, mars 2005.

[DGL+02] Jérôme DIDO, Nicolas GÉRAUDIE, Ludovic LOISEAU, Olivier PAYEUR, Yvon SAVARIAet Daniel POIRIER : A flexible floating-point format for optimizing data-paths andoperators in FPGA based DSPs. In 10th ACM/SIGDA International Symposiumon Field-programmable Gate Arrays (FPGA’02), pages 50–55, Monterey, CA, USA,février 2002. ACM Press.

[DMMM95] Marc DAUMAS, Christophe MAZENC, Xavier MERRHEIM et Jean-Michel MULLER :Modular range reduction : a new algorithm for fast and accurate computation of theelementary functions. Journal of Universal Computer Science, 1(3):162–175, mars1995.

[DR04] Christopher DOSS et Robert L. RILEY, Jr. : FPGA-based implementation of a robustIEEE-754 exponential unit. In J.M. ARNOLD et K.L. POCEK, éditeurs : 12th Annual

Bibliographie 125

IEEE Symposium on Field-Programmable CustomComputingMachines (FCCM’04),pages 229–238, Napa, CA, USA, avril 2004. IEEE Computer Society.

[DSM95] Debjit DAS SARMA et David W. MATULA : Faithful bipartite ROM reciprocal tables.In S. KNOWLES et W.H. MCALLISTER, éditeurs : Proceedings of the 12th IEEE Sym-posium on Computer Arithmetic (ARITH’12), pages 17–28, Bath, UK, juillet 1995.IEEE Computer Society.

[DSM97] Debjit DAS SARMA et David W. MATULA : Faithful interpolation in reciprocal tables.In T. LANG, J.-M. MULLER et N. TAKAGI, éditeurs : Proceedings of the 13th IEEESymposium on Computer Arithmetic (ARITH’13), pages 82–91, Asilomar, CA, USA,juillet 1997. IEEE Computer Society.

[DVKG05] Yong DOU, Stamatis VASSILIADIS, Georgi K. KUZMANOV et Georgi N. GAYDADJIEV :64-bit floating-point FPGA matrix multiplication. In 13th ACM/SIGDA Internatio-nal Symposium on Field-programmable Gate Arrays (FPGA’05), pages 86–95, Mon-terey, CA, USA, février 2005. ACM Press.

[EL94] Miloš D. ERCEGOVAC et Tomás LANG : Division and Square Root : Digit-RecurrenceAlgorithms and Implementations. Kluwer Academic Publishers, Norwell, MA, USA,juillet 1994.

[EL03] Miloš D. ERCEGOVAC et Tomás LANG : Digital Arithmetic. Morgan Kaufmann, SanFrancisco, CA, USA, juin 2003.

[EL05] Daniel ÉTIEMBLE et Lionel LACASSAGNE : Des flottants 16 bits sur microproces-seurs d’usage général pour images et multimédia. In M. AUGUIN et D. LAVENIER,éditeurs : Architecture des Ordinateurs, volume 24(6) de Technique et Science Infor-matiques, pages 645–665. Lavoisier, Cachan, France, novembre 2005.

[Far81] P. Michael FARMWALD : High bandwidth evaluation of elementary functions. InK.S. TRIVEDI et D.E. ATKINS, éditeurs : Proceedings of the 5th IEEE Symposium onComputer Arithmetic (ARITH’5), pages 139–142, Ann Arbor, MI, USA, mai 1981.IEEE Computer Society.

[FO01] Michael J. FLYNN et Stuart F. OBERMAN : Advanced Computer Arithmetic Design.John Wiley & Sons, New York, NY, USA, avril 2001.

[GFA+04] Maya GOKHALE, Janette FRIGO, Christine AHRENS, Justin L. TRIPP et Ron MIN-NICH : Monte Carlo radiative heat transfer simulation on a reconfigurable computer.In J. BECKER, M. PLATZNER et S. VERNALDE, éditeurs : Field-Programmable Logicand Applications : 14th International Conference, FPL 2004, numéro 3203 de Lec-ture Notes in Computer Science, pages 94–104, Antwerp, Belgium, septembre 2004.Springer-Verlag.

[GGL+05] Stéphane GUYETANT, Mathieu GIRAUD, Ludovic L’HOURS, Steven DERRIEN, Sté-phane RUBINI, Dominique LAVENIER et Frédéric RAIMBAULT : Cluster of re-configurable nodes for scanning large genomic banks. Parallel Computing, 31(1):73–96, janvier 2005.

[GLC+02] Altaf Abdul GAFFAR, Wayne LUK, Peter Y.K. CHEUNG, Nabeel SHIRAZI et JamesHWANG : Automating customisation of floating-point designs. In M. GLESNER,P. ZIPF et M. RENOVELL, éditeurs : Field-Programmable Logic and Applications :12th International Conference, FPL 2002, numéro 2438 de LectureNotes in ComputerScience, pages 523–533, Montpellier, France, septembre 2002. Springer-Verlag.

[GVH06] Yongfeng GU, Tom VANCOURT et Martin C. HERBORT : Integrating FPGA ac-celeration into the protomol molecular dynamics code : preliminary report. In

126 Bibliographie

J.M. ARNOLD et K.L. POCEK, éditeurs : 14th Annual IEEE Symposium on Field-Programmable Custom Computing Machines (FCCM’06), pages 315–316, Napa, CA,USA, avril 2006. IEEE Computer Society.

[GZCP04] Gokul GOVINDU, Ling ZHUO, Seonil CHOI et Viktor PRASANNA : Analysis of high-performance floating-point arithmetic on FPGAs. In 18th International Parallel andDistributed Processing Symposium (IPDPS’04), page 149, Santa Fe, NM, USA, avril2004. IEEE Computer Society.

[Har99] John HARRISON : A machine-checked theory of floating point arithmetic. In Y. BER-TOT, G. DOWEK, A. HIRSCHOWITZ, C. PAULIN et L. THÉRY, éditeurs : 12th Interna-tional Conference on Theorem Proving in Higher Order Logics (TPHOL’99), numéro1690 de Lecture Notes in Computer Science, pages 113–130, Nice, France, septembre1999. Springer-Verlag.

[HBP+05] Simon HAENE, Andreas BURG, David PERELS, Peter LUETHI, Norbert FELBER etWolfgang FICHTNER : FPGA implementation of Viterbi decoders for MIMO-BICM.In 39th Asilomar Conference on Signals, Systems & Computers, pages 734–738, Pa-cific Grove, CA, USA, novembre 2005. IEEE Signal Processing Society.

[HBW+05] Michael HASELMAN, Michael BEAUCHAMP, Aaron WOOD, Scott HAUCK, Keith D.UNDERWOOD et K. Scott HEMMERT : A comparison of floating point and logarithmicnumber systems for FPGAs. In J.M. ARNOLD et K.L. POCEK, éditeurs : 13th AnnualIEEE Symposiumon Field-Programmable CustomComputingMachines (FCCM’05),pages 181–190, Napa, CA, USA, avril 2005. IEEE Computer Society.

[IEE06] IEEE 754R WORKING GROUP : Draft standard for floating-point arithmetic P754,octobre 2006.

[JL95] Vijay K. JAIN et Lei LIN : High-speed double precision computation of nonlinearfunctions. In S. KNOWLES et W.H. MCALLISTER, éditeurs : Proceedings of the 12thIEEE Symposium on Computer Arithmetic (ARITH’12), pages 107–114, Bath, UK,juillet 1995. IEEE Computer Society.

[LB02] Barry LEE et Neil BURGESS : Parameterisable floating-point operations on FPGAs.In 36th Asilomar Conference on Signals, Systems & Computers, pages 1064–1068,Pacific Grove, CA, USA, novembre 2002. IEEE Signal Processing Society.

[LB03] Barry LEE et Neil BURGESS : A dual-path logarithmic number system addition/-subtraction scheme for FPGA. In P.Y.K. CHEUNG, G.A. CONSTANTINIDES et J.T.de SOUSA, éditeurs : Field-Programmable Logic and Applications : 13th Internatio-nal Conference, FPL 2003, numéro 2778 de LectureNotes in Computer Science, pages808–817, Lisbon, Portugal, septembre 2003. Springer-Verlag.

[Lew90] David M. LEWIS : An architecture for addition and subtraction of long word lengthnumbers in the logarithmic number system. IEEE Transactions onComputers, 39(11):1325–1336, novembre 1990.

[LKM02] Gerhard LIENHART, Andreas KUGEL et Reinhard MÄNNER : Using floating-pointarithmetic on FPGAs to accelerate scientific N-body simulations. In J.M. ARNOLD etK.L. POCEK, éditeurs : 10th Annual IEEE Symposium on Field-Programmable Cus-tom Computing Machines (FCCM’02), pages 182–191, Napa, CA, USA, avril 2002.IEEE Computer Society.

[LLVC03] Dong-U LEE, Wayne LUK, John D. VILLASENOR et Peter Y.K. CHEUNG : Hierarchicalsegmentation schemes for function evaluation. In IEEE International Conferenceon Field-Programmable Technology (FPT’03), pages 92–99, Tokyo, Japan, décembre2003. IEEE.

Bibliographie 127

[LMM+98] Walter B. LIGON, III, Scott MCMILLAN, Greg MONN, Kevin SCHOONOVER, Fred STI-VERS et Keith D. UNDERWOOD : A re-evaluation of the practicality of floating-pointoperations on FPGAs. In J.M. ARNOLD et K.L. POCEK, éditeurs : 6th Annual IEEESymposium on FPGAs for CustomComputing Machines (FCCM’98), pages 206–215,Napa, CA, USA, avril 1998. IEEE Computer Society.

[LMT98] Vincent LEFÈVRE, Jean-Michel MULLER et Arnaud TISSERAND : Toward correctlyrounded transcendentals. IEEE Transactions on Computers, 47(11):1235–1243, no-vembre 1998.

[Mar00] Peter MARKSTEIN : IA-64 and Elementary Functions – Speed and Precision. Hewlett-Packard Professional Books. Prentice Hall, Upper Saddle River, NJ, USA, juin 2000.

[MB06] Allen MICHALSKI et Duncan BUELL : A scalable architecture for RSA cryptographyon large FPGAs. In J.M. ARNOLD et K.L. POCEK, éditeurs : 14th Annual IEEE Sympo-sium on Field-Programmable Custom Computing Machines (FCCM’06), pages 331–332, Napa, CA, USA, avril 2006. IEEE Computer Society.

[MST98] Jean-Michel MULLER, Alexandre SCHERBYNA et Arnaud TISSERAND : Semi-logarithmic number systems. IEEE Transactions onComputers, 47(2):145–151, février1998.

[MTP+02] Rudolf MATOUŠEK, Milan TICHÝ, Zdenek POHL, Jirí KADLEC, Chris I. SOFTLEY etJ. Nick COLEMAN : Logarithmic number system and floating-point arithmetics onFPGA. In M. GLESNER, P. ZIPF et M. RENOVELL, éditeurs : Field-ProgrammableLogic and Applications : 12th International Conference, FPL 2002, numéro 2438 deLecture Notes in Computer Science, pages 627–636, Montpellier, France, septembre2002. Springer-Verlag.

[MTVC05] Romain MICHARD, Arnaud TISSERAND et Nicolas VEYRAT-CHARVILLON : Divgen :a divider unit generator. In F.T. LUK, éditeur : Advanced Signal Processing Algo-rithms, Architectures, and Implementations XV, volume 5910, page 59100M, SanDiego, CA, USA, août 2005. SPIE.

[Mul89] Jean-Michel MULLER : Arithmétique des Ordinateurs. Masson, Paris, France, juillet1989.

[Mul99] Jean-Michel MULLER : A few results on table-based methods. Reliable Computing,5(3):279–288, août 1999.

[Mul05a] Jean-Michel MULLER : Elementary Functions, Algorithms and Implementation. Bir-khäuser, Boston, MA, USA, octobre 2005.

[Mul05b] Jean-Michel MULLER : On the definition of ulp(x). Research Report RR2005-09, Labo-ratoire de l’Informatique du Parallélisme, École Normale Supérieure de Lyon, Lyon,France, février 2005.

[Ng92] Kwok C. NG : Argument reduction for huge arguments : good to the last bit. Tech-nical report, SunPro, Mountain View, CA, USA, juillet 1992.

[OHDP03] Fernando E. ORTIZ, John R. HUMPHREY, James P. DURBANO et DennisW. PRATHER :A study on the design of floating-point functions in FPGAs. In P.Y.K. CHEUNG, G.A.CONSTANTINIDES et J.T. de SOUSA, éditeurs : Field-Programmable Logic and Ap-plications : 13th International Conference, FPL 2003, numéro 2778 de Lecture Notesin Computer Science, pages 1131–1134, Lisbon, Portugal, septembre 2003. Springer-Verlag.

[OS05] Stuart F. OBERMAN et Michael Y. SIU : A high-performance area-efficient multifunc-tion interpolator. In P. MONTUSCHI et E. SCHWARZ, éditeurs : Proceedings of the

128 Bibliographie

17th IEEE Symposium on Computer Arithmetic (ARITH’17), pages 272–279, CapeCod, MA, USA, juin 2005. IEEE Computer Society.

[Par99] Behrooz PARHAMI : Computer Arithmetic : Algorithms and Hardware Designs. Ox-ford University Press, Oxford, UK, octobre 1999.

[PB02] José-Alejandro PIÑEIRO et Javier D. BRUGUERA : High-speed double-precision com-putation of reciprocal, division, square root, and inverse square root. IEEE Transac-tions on Computers, 51(12):1377–1388, décembre 2002.

[PBM01] José-Alejandro PIÑEIRO, Javier D. BRUGUERA et Jean-Michel MULLER : Faithful po-wering computation using table look-up and a fused accumulation tree. In N. BUR-GESS et L. CIMINIERA, éditeurs : Proceedings of the 15th IEEE Symposium on Com-puter Arithmetic (ARITH’15), pages 40–47, Vail, CO, USA, juin 2001. IEEE ComputerSociety.

[PG05] Mihail PETROV et Manfred GLESNER : Optimal FFT architecture selection for OFDMreceivers on FPGA. In G. BREBNER, S. CHAKRABORTY et W.-F. WONG, éditeurs :IEEE International Conference on Field-Programmable Technology (FPT’05), pages313–314, Singapore, décembre 2005. IEEE.

[PH83] Mary H. PAYNE et Robert N. HANEK : Radian reduction for trigonometric functions.ACM SIGNUMNewsletter, 18(1):19–24, janvier 1983.

[PS96] Vassilis PALIOURAS et Athanasios STOURAITIS : A novel algorithm for accurate lo-garithmic number system subtraction. In IEEE International Symposium on Circuitsand Systems (ISCAS’96), pages 268–271, Atlanta, GA, USA, mai 1996. IEEE.

[PW76] George PAUL et M. Wayne WILSON : Should the elementary function library beincorporated into computer instruction sets ? ACM Transactions on MathematicalSoftware, 2(2):132–142, juin 1976.

[PWSW05] Panan POTIPANTONG, Theerayod WIANGTONG, Phaophak SIRISUK et Apisak WO-RAPISHET : A scaleable FFT/IFFT kernel for communication systems using codesignapproach. In G. BREBNER, S. CHAKRABORTY et W.-F. WONG, éditeurs : IEEE In-ternational Conference on Field-Programmable Technology (FPT’05), pages 329–330,Singapore, décembre 2005. IEEE.

[Rem34] Evgeny Y. REMEZ : Sur un procédé convergent d’approximations successives pourdéterminer les polynômes d’approximation. Comptes-rendus de l’Académie desSciences, 198:2063–2065, juin 1934.

[RN02] Eric ROESLER et Brent NELSON : Novel optimizations for hardware floating-pointunits in a modern FPGA architecture. In M. GLESNER, P. ZIPF et M. RENOVELL, édi-teurs : Field-Programmable Logic and Applications : 12th International Conference,FPL 2002, numéro 2438 de Lecture Notes in Computer Science, pages 637–646, Mont-pellier, France, septembre 2002. Springer-Verlag.

[SA75] Earl E. SWARTZLANDER, Jr. et AristidesG. ALEXOPOULOS : The sign/logarithmnum-ber system. IEEE Transactions on Computers, C-24(12):1238–1242, décembre 1975.

[Sil05] Silicon Graphics, Inc., Mountain View, CA, USA. SGI RASC technology, octobre 2005.[SRCL92] Satwant SINGH, Jonathan ROSE, Paul CHOW et David LEWIS : The effect of logic

block architecture on FPGA performance. IEEE Journal of Solid-State Circuits, 27(3):281–287, mars 1992.

[SS97] Michael J. SCHULTE et James E. STINE : Symmetric bipartite tables for accurate func-tion approximation. In T. LANG, J.-M. MULLER et N. TAKAGI, éditeurs : Proceedingsof the 13th IEEE Symposium on Computer Arithmetic (ARITH’13), pages 175–183,Asilomar, CA, USA, juillet 1997. IEEE Computer Society.

Bibliographie 129

[SS99] James E. STINE et Michael J. SCHULTE : The symmetric table addition method foraccurate function approximation. Journal of VLSI Signal Processing Systems, 21(2):167–177, juin 1999.

[Tak98] Naofumi TAKAGI : Powering by a table look-up and a multiplication with operandmodification. IEEE Transactions on Computers, 47(11):1216–1222, novembre 1998.

[Tan91] P.T. Peter TANG : Table-lookup algorithms for elementary functions and their erroranalysis. In P. KORNERUP et D.W. MATULA, éditeurs : Proceedings of the 10th IEEESymposium on Computer Arithmetic (ARITH’10), pages 232–236, Grenoble, France,juin 1991. IEEE Computer Society.

[TGJR88] Fred J. TAYLOR, Rabinder GILL, Jim JOSEPH et Jeff RADKE : A 20 bit logarithmicnumber system processor. IEEE Transactions on Computers, 37(2):190–200, février1988.

[THG05] César TORRES-HUITZIL et Bernard GIRAU : FPGA implementation of an exci-tatory and inhibitory connectionist model for motion perception. In G. BREB-NER, S. CHAKRABORTY et W.-F. WONG, éditeurs : IEEE International Conferenceon Field-Programmable Technology (FPT’05), pages 259–266, Singapore, décembre2005. IEEE.

[TMS+06] Tatsuhiro TACHIBANA, Yoshihiro MURATA, Naoki SHIBATA, Keiichi YASUMOTO etMinoru ITO : General architecture for hardware implementation of genetic algo-rithm. In J.M. ARNOLD et K.L. POCEK, éditeurs : 14th Annual IEEE Symposiumon Field-Programmable Custom Computing Machines (FCCM’06), pages 291–292,Napa, CA, USA, avril 2006. IEEE Computer Society.

[TOML04] James W. THOMAS, John P. OKADA, Peter MARKSTEIN et Ren-Chang LI : The libmlibrary and floating-point arithmetic in HP-UX for Itanium-based systems. Technicalreport, Hewlett-Packard Company, Palo Alto, CA, USA, décembre 2004.

[Und04] Keith D. UNDERWOOD : FPGAs vs. CPUs : trends in peak floating-point performance.In 12th ACM/SIGDA International Symposiumon Field-programmable Gate Arrays(FPGA’04), pages 171–180, Monterey, CA, USA, février 2004. ACM Press.

[VLG06] Julio VILLALBA, Tomás LANG et Mario A. GONZALEZ : Double-residue modularrange reduction for floating-point hardware implementations. IEEE Transactions onComputers, 55(3):254–267, mars 2006.

[WG94] Weng-Fai WONG et Eiichi GOTO : Fast hardware-based algorithms for elementaryfunction computations using rectangular multipliers. IEEE Transactions on Compu-ters, 43(3):278–294, mars 1994.

[WHYC06] Kevin WHITTON, X. Sharon HU, Cedric X. YU et Danny Z. CHEN : An FPGA solutionfor radiation dose calculation. In J.M. ARNOLD et K.L. POCEK, éditeurs : 14th AnnualIEEE Symposium on Field-Programmable CustomComputingMachines (FCCM’06),pages 227–236, Napa, CA, USA, avril 2006. IEEE Computer Society.

[Xil05] Xilinx, Inc., San Jose, CA, USA. Virtex-II platform FPGAs : complete data sheet, mars2005.

arithmétiques réelles sur fpga · iv remerciements blagues sur le gruyère à trous et, preuve...

Documents