Processeur de signal numérique

La représentation des résultats et leur précision joue un rôle fondamental dans la majorité des algorithmes de traitement de signal. Et les DSP doivent être conçus en conséquence. Pour donner un exemple, ceux-ci doivent gérer les dépassements d'entier de plusieurs façons différentes.

Il arrive qu'un calcul donne un résultat qui demande plus de bits que disponible pour être représenté. Par exemple, si un processeur a des registres de 32 bits, il ne pourra pas stocker un nombre comme 5 000 000 000, qui a besoin de 33 bits. Ce genre de situation s'appelle un dépassement d'entier. Sur les processeurs généralistes, ces situations sont gérées via l'arithmétique modulaire. Pour faire simple, le résultat stocké dans les registres sera identique au vrai résultat, à part que les bits de poids fort (les bits en trop) seront perdus. Cela a un défaut majeur : l'addition (ou la multiplication) de deux nombres très grands peut donner un nombre très petit. Et cela peut donner des résultats assez bizarres : un son trop fort peut devenir soudainement très faible au lieu de saturer. (mais inaudible car bien trop courte).

Pour éviter cela, les DSP permettent de gérer ces situations différemment en utilisant l'arithmétique saturée. Avec cette arithmétique, si un résultat devient trop grand pour être stocké dans un registre, le résultat est arrondi à la plus grande valeur que peut contenir ce registre.

Les DSP peuvent gérer les dépassements d'entier des deux façons. La manière de réagir peut être précisée par la valeur de certains bits, placés dans certains registres du processeur, comme pour d'autres paramètres. Une autre façon de faire aurait été de fournir les instructions de calcul en double : une version qui gère la situation avec l'arithmétique modulaire, et une autre avec l’arithmétique saturée. Mais cela aurait eu des désavantages, entre autres demander de doubler le nombre d'instructions.

Pour plus d’efficacité dans certaines applications numériques, les DSP peuvent gérer nativement un format de données spécial : les nombres flottants par blocs. Comme leur nom l’indique, il s'agit de nombres flottants, c'est-à-dire de nombres à virgules dont le nombre de décimales après la virgule peut varier. Ceux-ci sont représentés en mémoire sous la forme d'un bit de signe, d'une mantisse, et d'un exposant.

Dans certains cas, il arrive que les nombres flottants à manipuler dans différents calculs aient tous le même exposant. Les nombres flottants par blocs permettent de mutualiser cet exposant entre plusieurs nombres flottants. L'exposant est ainsi stocké une seule fois en mémoire, et n'est pas dupliqué. Par exemple, s'il faut encoder 8 nombres flottants dans ce format, il faudra utiliser un mot mémoire pour l'exposant, et 8 autres pour les mantisses et les signes de chaque nombres. Avec des flottants normaux, il faudrait utiliser 8 mots mémoires pour les mantisses et les signes, et 8 autres pour les exposants.

Bien sûr, nos DSP^{[Lesquels ?]} supportent des instructions pour ces flottants par blocs. Ils contiennent notamment des instructions de calcul sur de tels flottants. Ils contiennent aussi une instruction pour charger l'exposant dans un registre, les calculs effectués dans ce format sont alors automatiquement effectués avec cet exposant. On trouve aussi des instructions de conversions entre les divers formats de flottants.

Les DSP sont capables de gérer des boucles FOR en un seul cycle d'horloge. Ces boucles s’exécutent un nombre fixé de fois, fixé par un indice. Cet indice est incrémenté ou décrémenté à chaque itération de la boucle. Nos DSP ^{[Lesquels ?]} possèdent des instructions capables d'effectuer un branchement, ainsi qu'une décrémentation/incrémentation de cet indice. Pour faciliter l'implémentation de ces instructions, cet indice est souvent placé dans des registres spécialisés, dont le seul rôle est de stocker ces compteurs.

Autre fonctionnalité d’accélération des boucles : les instructions auto-répétantes. Dans certains cas, il n'est pas rare que les boucles d'un programme ne fassent s'appliquer une seule et unique instruction sur tous les éléments d'un tableau. C'est par exemple le cas pour l'addition de tous les éléments d'un tableau. Ou encore, la multiplication de tous les éléments d'un tableau entre eux.

Certains DSP sont capables d'effectuer des boucles en une seule instruction. Ces instructions effectuent cette opération, ainsi que toutes les instructions de gestion de la boucle en un seul cycle d'horloge. Qui plus est, elle se répètent automatiquement toutes seules, tant qu'elles ne rencontrent pas la condition de sortie de boucle.

Pour gagner en performance, cette instruction est stockée dans une petite mémoire temporaire, afin d'éviter d'avoir à charger celle-ci depuis la mémoire à chaque exécution (chaque tour de boucle).

Cette fonctionnalité a parfois été améliorée en permettant d'effectuer cette répétition non seulement sur des instructions unique, mais aussi sur de petites suites d'instructions. Pour ce faire, ils peuvent utiliser une petite mémoire cache pour exécuter de petites boucles rapidement et sans accéder à la mémoire. Cette mémoire a souvent une taille limitée à quelques instructions : 16 à 32 environ.

Adressage indirect à registre post-incrémenté

Les données manipulées par nos DSP^{[Lesquels ?]} sont très souvent rassemblées dans des tableaux, qui sont parcourus du début à la fin (ou de la fin vers le début). Pour accélérer ces parcours de tableaux, les DSP incorporent des modes d'adressages spécialisés. Ils utilisent notamment le mode d'adressage post-incrémenté(décrémenté). Avec ce mode d'adressage, l'adresse de l’élément du tableau à lire ou écrire est stockée dans un registre. À chaque fois qu'une instruction accède à l'adresse contenue dans ce registre, cette adresse est incrémentée ou décrémentée de façon à pointer sur le prochain élément dans le tableau. Ce mode d'adressage permet d'effectuer cette incrémentation ou décrémentation automatiquement. Ils implémentent aussi une variante de ce mode d'adressage dans lequel l'incrémentation ou décrémentation s'effectue avant l'utilisation effective de l'adresse.

Les DSPs implémentent des modes d'adressages servant à faciliter l’utilisation de files, des structures de données spéciales, utilisées occasionnellement par les programmeurs de DSP. Ces structures sont des zones de mémoire dans lesquelles on stocke des données dans un certain ordre. On peut y ajouter de nouvelles données, et en retirer. Quand on retire une donnée, c'est la donnée la plus ancienne qui quitte la file.

fonctionnement d'une file - 2

Ces files sont implémentées avec un tableau, auquel on ajoute deux adresses mémoires : une pour indiquer le début de la file, et l'autre la fin. Le début de la file correspond à l'endroit en mémoire où l'on va insérer les nouvelles données. La fin de la file correspond à la position de la donnée la plus ancienne en mémoire.

À chaque ajout de donnée, l'adresse de la donnée la plus récente est augmentée de la taille de la donnée, afin de réserver la place pour la donnée à ajouter. De même, lors d'une suppression, le pointeur de la donnée la plus ancienne est aussi augmenté, afin de libérer la plus place qu'il occupait.

fonctionnement d'une file - 3

Ce tableau a une taille fixe. Si jamais celui-ci se remplit jusqu'à la dernière case, (ici la 5^e), il se peut malgré tout qu'il reste de la place au début du tableau : des retraits ont libéré de la place. L'insertion des données reprend au tout début du tableau.

Ce mode de fonctionnement nécessite de vérifier à chaque insertion si l'on a atteint la fin du tableau, avec l'aide d'une comparaison entre adresses De plus, si l'on arrive à la fin du tableau, l'adresse de la donnée la plus récemment ajoutée doit être remise à la bonne valeur : celle pointant sur le début du tableau.

Le mode d'adressage modulo a été inventé pour supprimer la comparaison et la gestion logicielle des débordements. Avec ce mode d'adressage, les deux adresses sont adressées en utilisant le mode d'adressage indirect à registre post ou pré-indexé : l'incrémentation de l'adresse au retrait ou à l'ajout est effectué automatiquement. Ce mode d'adressage vérifie automatiquement que l'adresse ne déborde pas du tableau lors d'une insertion. Si cette adresse « déborde », le processeur la fait pointer au début du tableau. Suivant le DSP, ce mode d'adressage est géré plus ou moins différemment.

La première méthode utilise des registres modulos. Ces registres vont stocker la taille du tableau servant à implémenter notre file. Chacun de ces registres est associé à un registre d'adresse : si jamais on utilise l'adressage modulo dans ce registre d'adresse, le processeur utilisera le contenu du registre modulo pour faire ce qu'il faut. Pour gérer l'adresse de début, le processeur va imposer quelques contraintes sur l'adresse de départ de ce tableau. Cette adresse est souvent alignée à des adresses bien précises, souvent un multiple de 64, 128, ou 256. L'adresse de début de la file est donc le multiple de 64, 128, 256 strictement inférieur le plus proche de l'adresse manipulée.

Autre solution : utiliser deux registres : un pour stocker l'adresse de début du tableau, et un autre pour sa longueur. Certains processeurs DSP utilisent un registre pour stocker l'adresse de début, et un autre pour l'adresse de fin.

Les DSP supportent un dernier mode d'adressage : l'adressage bit-reverse. Ce mode d'adressage sert à accélérer les calculs de transformées de Fourier rapides. Ces calculs de transformée de Fourier étant courants en traitement de signal, un mode d'adressage spécial lui est réservé.

Cet algorithme a la fâcheuse tendance à produire ses résultats dans un ordre différent des données de départ. En gros, cet algorithme va prendre des données, stockées dans un tableau, et va fournir des résultats, eux aussi écrits dans un tableau. L'ordre de calcul des résultats dans le tableau d'arrivée suit une logique particulière. Les bits de l'adresse du résultat sont partiellement inversés comparé aux bits de l'adresse normale.

Par exemple, pour un tableau de 8 cases, numérotées 0,1, 2, 3, 4, 5, 6, 7, les données arrivent dans cet ordre : 0, 4, 2, 6, 1, 5, 3, 7.

Les DSPs disposent donc d'un mode d’adressage qui inverse tout ou partie des bits d'une adresse mémoire, afin de gérer plus facilement les calculs de FFT. Une autre technique consiste à calculer nos adresses différemment. Lors de l'ajout d'un indice à notre adresse, la direction de propagation de la retenue de l'addition est inversée. Certains DSP disposent d'instructions pour faire ce genre de calculs.

Par exemple, un DSP aura souvent des registres entiers séparés des registres flottants. Certains registres ne pourront ainsi stocker que des nombres entiers, et d'autres uniquement des flottants. Comme autre exemple, certains registres sont spécialisés dans le stockage des adresses mémoires. On peut aussi trouver des registres spécialisés pour retenir des indices de tableaux, ou des compteurs de boucles.

De plus, certaines instructions du processeurs, ainsi que l'usage de certains modes d'adressages, ne sont possibles que sur certains types de registres. Par exemple, certaines instructions ne peuvent manipuler que les registres entiers et pas les autres. Cette spécialisation des registres pose de nombreux problèmes pour les compilateurs, qui peuvent donner lieu à une génération de code sous-optimale.

De nombreuses applications de traitement de signal ont besoin d'une grande précision. Pour que cela ne devienne pas rapidement une source d'erreur dans les calculs, les DSP sont dotés de registres accumulateurs très grands, capables de retenir des résultats de calcul intermédiaires sans perte de précision.

Les DSP utilisent donc des registres accumulateurs très larges. Par exemple, l'UAL (unité arithmétique et logique) des DSP de la famille DSP56k de Motorola dispose de quatre registres d'entrée de 24 bits, deux registres accumulateurs de 48 bits et deux extensions de 8 bits des registres accumulateurs. Ces dernières permettent d'obtenir une précision de 56 bits sur les registres accumulateurs, laquelle offre une bonne précision aux calculs successifs et simplifie la gestion des erreurs pour le programmeur.