Présentation

La conception de filtres numériques avec une latence minimale est une exigence fondamentale pour le traitement des flux de données à haute vitesse dans les systèmes en temps réel. Du traitement des signaux radar et des moteurs de trading radio à haute fréquence, le retard entre l'entrée et la sortie affecte directement les performances et la justesse du système. VHDL (VHSIC Hardware Description Language) demeure un outil dominant pour la mise en œuvre de ces filtres sur les FPGA et les CAS, offrant un contrôle granulaire sur le timing, l'utilisation des ressources et l'architecture.

Les fondamentaux des filtres numériques à faible latence

La latence dans un filtre numérique est le temps qu'il faut pour un seul échantillon d'entrée pour produire un échantillon de sortie correspondant, mesuré en cycles d'horloge ou en temps absolu. Pour les applications à grande vitesse, chaque cycle compte. Un filtre qui ajoute même quelques centaines de nanosecondes de retard peut dégrader le contrôle en boucle fermée ou causer une perte de paquets dans les télécommunications.

La mesure primaire est latence de sortie[, souvent définie comme le nombre de cycles d'horloges de la première entrée valide à la première sortie valide. Pour les données de streaming, les ingénieurs considèrent également délais de groupe, qui est le délai moyen des composants de fréquence du filtre.

Les applications qui exigent une faible latence comprennent :

  • Trading haute fréquence (HFT) – la latence de microseconde détermine la rentabilité.
  • La guerre radar et électronique – la détection en temps réel de cibles nécessite un délai de traitement minimal.
  • Radio définie par logiciel (SDR)[ – le filtrage des canaux doit se tenir avec les CDA à large bande.
  • Imagerie médicale – l'échographie et la formation de faisceaux d'IRM nécessitent des filtres numériques à faible latence pour la rétroaction en direct.

Comprendre ces cas d'utilisation aide les concepteurs à justifier l'affectation des ressources et les choix d'architecture.

VHDL pour la conception des filtres: forces et limites

VHDL fournit un cadre rigoureux pour décrire le comportement matériel concurrent. Sa sémantique forte de typage, ses génériques et ses fonctions de signal le rendent idéal pour les implémentations de filtres qui doivent être synthétisées et correctes au moment. Contrairement aux langages de haut niveau comme C, VHDL expose le niveau de transfert de registre (RTL) sous-jacent, permettant aux concepteurs d'optimiser la latence au niveau de la porte.

Les principaux avantages de l'utilisation de VHDL pour les filtres à faible latence sont les suivants :

  • Parallélisme explicite – Les processus VHDL s'exécutent simultanément, reflétant la nature parallèle de la logique FPGA.
  • Le contrôle direct des tongs – le concepteur décide où les registres sont insérés.
  • Genericity – l'utilisation de génériques pour la largeur des coefficients, l'ordre des filtres et la profondeur des pipelines permet des conceptions réutilisables.
  • Fidlité de simulation – VHDL simule les retards au niveau de la porte (annotation de retour SDF) pour une prédiction précise de la latence.

Cependant, VHDL a aussi des limites : il est verbeux pour les conceptions à grande échelle, et la pipeline manuelle peut être sujette aux erreurs. Les fournisseurs FPGA modernes fournissent des outils de synthèse de haut niveau (HLS) qui génèrent VHDL à partir du code C/C++, mais pour les exigences ultra-faible latence, VHDL codé à la main reste supérieur parce qu'il élimine les frais généraux imposés par l'outil.

Architectures de filtres : RIP contre la latence IIR

Le choix entre les filtres de réponse à l'impulsion Finite (FIR) et de réponse à l'impulsion Infinite (IIR) influe fortement sur la latence réalisable.

Filtres FIR pour latence prévisible

Les filtres FIR sont intrinsèquement stables et ont une phase linéaire (lorsque les coefficients sont symétriques). Leur latence est principalement déterminée par le nombre de robinets et la profondeur du pipeline à l'intérieur de la chaîne multi-accumulation (MAC). Pour un FIR en forme directe N-tap, la latence est au moins des cycles N si une MAC entièrement série est utilisée, mais les implémentations parallèles peuvent réduire ce nombre à un ou deux cycles.

Les modèles FIR à faible latence utilisent souvent un tableau systolique ou une architecture entièrement parallèle où chaque robinet a un multiplicateur et un adder dédiés, et les résultats sont résumés à travers un arbre d'addition. Le chemin critique est l'arborescence de l'adder, qui peut être brisée en étapes pour maintenir des fréquences d'horloges élevées. Par exemple, un FIR de 32 tap avec un arbre d'addition de profondeur 5 (2^5 = 32) a une latence de 5 cycles d'horloges plus des registres d'entrée/sortie, généralement 6-8 cycles au total.

Filtres IIR : compacts mais sensibles à la latence

Dans les structures récursives (p. ex., la forme directe II), la sortie dépend des sorties précédentes, de sorte que la canalisation à l'intérieur de la boucle est difficile. L'ajout de registres de pipelines dans le chemin de rétroaction modifie la fonction de transfert du filtre à moins que l'architecture ne soit restructurée (p. ex., la canalisation à l'avant ou l'approche éparpillée). Pour les flux de données à grande vitesse, les filtres IIR sont généralement évités, sauf si les contraintes de zone dominent. Lorsqu'ils doivent être utilisés, l'interleaving de la canalisation et la mise à l'échelle du coefficient[ peut atténuer certaines pénalités de latence.

Dans de nombreux modèles à grande vitesse, les filtres FIR sont le choix par défaut car leur latence prévisible s'harmonise avec des protocoles de streaming comme AXI4-Stream, où la poignée de main doit se produire dans un nombre fixe de cycles.

Stratégies clés de conception pour une faible latence dans la VHDL

La mise en place de filtres à faible latence dans la LHDV nécessite une approche systématique de la pipeline, du parallélisme et de la cartographie des ressources.

Pipeline : briser le sentier critique

La canalisation est la façon la plus efficace de réduire la latence en raccourcissant le trajet combiné entre les registres. Dans un filtre sans la canalisation, le trajet critique s'effectue à partir d'un registre d'entrée par des multiplicateurs, des adders et éventuellement des retours, limitant la vitesse maximale de l'horloge. En insérant des registres de pipelines à des étapes appropriées, la période d'horloge peut être réduite tout en maintenant le débit. Chaque étape de pipeline ajoute un cycle d'horloge de latence, mais la latence totale dans le temps (cycles d'horloge * période) peut baisser considérablement parce que la période est plus petite.

Par exemple, un FIR de 16 tap non-pipéline pourrait avoir un chemin critique de 50 ns, limitant la fréquence des horloges à 20 MHz. Avec deux étapes de pipeline, la période de traitement se réduit à 20 ns, et le total des latences du système (y compris les registres d'entrées-sorties) pourrait être de 4 cycles × 20 ns = 80 ns, contre 50 ns non-pipélined. Dans ce cas, la canalisation en fait augmente le nombre de cycles mais réduit le temps absolu si l'amélioration de la fréquence est suffisante.

Parallélisme et rétorsion

Au lieu de traiter un échantillon par cycle d'horloge, un filtre parallèle traite plusieurs échantillons en parallèle pour obtenir un débit plus élevé sans augmenter la fréquence de l'horloge. Pour les flux de données à grande vitesse où le taux d'échantillonnage d'entrée dépasse le taux d'horloge en tissu FPGA (p. ex., un ADC de 1 GHz alimentant un FPGA de 250 MHz), le filtre doit être polyphase ou parallèle. Dans VHDL, cela est mis en œuvre en reproduisant la structure du filtre et en interlevant les données d'entrée.

Optimisation des ressources : blocs DSP et logique distribuée

Les FPGA modernes contiennent des tranches DSP dédiées (par exemple Xilinx DSP48E2, blocs Intel DSP) qui intègrent un multiplicateur, un addeur et un accumulateur dans une cellule unique. Ces blocs sont le moyen le plus rapide pour mettre en œuvre des opérations MAC parce qu'ils ont des chaînes de canalisations internes et des chaînes de transport dédiées. Lors de l'écriture de VHDL, les blocs DSP instantanés utilisent directement les déclarations de composants (ou les infèrent en suivant les directives de codage des fournisseurs) pour obtenir une latence minimale.

Pour le stockage des coefficients, utilisez le bloc RAM (BRAM) comme ROM, mais sachez que la latence de lecture BRAM est généralement de 2 cycles. Pour minimiser cela, entreposez les coefficients dans la mémoire LUT distribuée (SRL32 ou registres simples) si l'ordre de filtre est petit. L'échange entre l'utilisation des ressources et la latence doit être évalué par conception.

Mise en œuvre étape par étape : un filtre FIR à 8 tap de faible latence dans la LHDV

Cet exemple illustre un filtre RIP entièrement parallèle et en pipeline avec 8 coefficients symétriques. La conception utilise un arbre d'addition de pipelines pour garder le chemin critique court.

-- 8-tap symmetric FIR, fully parallel
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;

entity fir_low_latency is
 generic (
 DATA_WIDTH : integer := 16;
 COEF_WIDTH : integer := 16
 );
 port (
 clk : in std_logic;
 reset : in std_logic;
 data_in : in std_logic_vector(DATA_WIDTH-1 downto 0);
 valid_in: in std_logic;
 data_out: out std_logic_vector(DATA_WIDTH+COEF_WIDTH-1 downto 0);
 valid_out: out std_logic
 );
end fir_low_latency;

architecture rtl of fir_low_latency is
 -- coefficient ROM (single cycle read)
 constant COEFFS : integer_array(0 to 7) := ( ... );
 -- internal registers
 signal tap_regs : array(0 to 7) of signed(DATA_WIDTH-1 downto 0);
 signal prod : array(0 to 7) of signed(DATA_WIDTH+COEF_WIDTH-1 downto 0);
 signal sum_stage1, sum_stage2, sum_stage3 : signed(DATA_WIDTH+COEF_WIDTH-1 downto 0);
begin
 -- input shift register
 process(clk)
 begin
 if rising_edge(clk) then
 if valid_in = '1' then
 tap_regs(0) <= signed(data_in);
 for i in 1 to 7 loop
 tap_regs(i) <= tap_regs(i-1);
 end loop;
 end if;
 end if;
 end process;

 -- pipeline stage: multiply (one cycle)
 process(clk)
 begin
 if rising_edge(clk) then
 for i in 0 to 7 loop
 prod(i) <= tap_regs(i) * COEFFS(i);
 end loop;
 end if;
 end process;

 -- pipeline stage: adder tree (3 cycles for 8 inputs)
 process(clk)
 begin
 if rising_edge(clk) then
 -- stage 1: pair sums
 sum_stage1 <= prod(0) + prod(1) + prod(2) + prod(3);
 sum_stage2 <= prod(4) + prod(5) + prod(6) + prod(7);
 -- stage 2: final sum
 sum_stage3 <= sum_stage1 + sum_stage2;
 end if;
 end process;

 -- output register
 process(clk)
 begin
 if rising_edge(clk) then
 data_out <= std_logic_vector(sum_stage3);
 valid_out <= valid_in; -- delayed by 5 cycles total
 end if;
 end process;
end rtl;

Cette conception introduit un total de 5 étapes de pipeline (déplacement d'entrée, multiplication, deux étapes d'arbre d'addition, et sortie), ce qui entraîne une latence de 5 cycles d'horloge. L'arbre d'addition utilise plusieurs registres de pipeline pour éviter de longs trajets combinés.

Notez que le signal valide out doit être retardé du même nombre de cycles que le chemin de données. Ceci est critique dans les interfaces de streaming pour maintenir l'alignement. Dans VHDL, un simple registre de décalage sur le signal valide atteint ceci.

Vérification et essai des filtres à faible latence

La simulation est essentielle pour confirmer la réponse de fréquence du filtre et sa latence. Utilisez un testbench qui alimente des séquences d'entrée connues (impulsion, pas, sinusoïdal) et mesure la différence de temps entre les affirmations d'entrée et de sortie. Dans VHDL, vous pouvez utiliser des énoncés `assert` avec `maintenant` (temps de simulation) pour valider que la latence ne dépasse pas une limite spécifiée.

Pour les flux de données à grande vitesse, vérifiez également données valides poignées de mains et [pression de contre-pression[ (si l'on utilise AXI4-Stream). La latence de la logique valide/prête elle-même ajoute à la latence globale du système; gardez-la minimale en évitant la rétroaction combinatoire dans les chemins de poignée de mains.

Techniques avancées pour la latence sous-cycle

Arithmétique distribué (DA)

L'arithmétique distribuée remplace les multiplicateurs par des tables de recherche précalculées (LUT) et des décalages, ce qui peut réduire le nombre de phases de pipeline pour certains modèles de coefficients. Cependant, DA est le mieux adapté pour les filtres FIR à coefficient fixe où le nombre de robinets est modéré. Sa latence est égale au nombre de bits par échantillon (si l'on utilise le série binaire) ou peut être réduit en utilisant le DA par défaut.

Les tableaux systoliques

Pour un filtre FIR, un tableau systolique peut obtenir un débit d'une sortie par cycle d'horloge avec une latence égale au nombre de robinets (plus les étapes de pipeline). Chaque élément de traitement est un multi-ajout avec le registre local. Le code VHDL se trouve directement sur le matériel et la régularité simplifie la fermeture du timing. Les tableaux Sysolique sont populaires dans les applications de calcul haute performance et de filtre FIR pour les convertisseurs numériques.

Pipeline personnalisée de l'arbre Adder

Pour les filtres très larges (p. ex. 128 robinets), l'arbre d'addition peut être borné de façon non-binaire (p. ex., utiliser des adders à glissière) pour réduire la latence. L'addition à l'enregistrement comprime trois nombres en deux (produit partiel et transport) sans propagation complète, puis le résultat final est calculé en un seul adder rapide. Cette technique est utilisée dans les blocs DSP48E2 et peut être exploitée en VHDL en injectant la tranche DSP en mode « MAC ».

Meilleures pratiques et pièges communs

  • Toujours oléogénériser le signal valide en parallèle avec les données pour maintenir l'alignement. Une erreur courante est d'oublier de retarder les signaux de poignée de main, ce qui entraîne une latence mal appariée et la corruption des données.
  • Utilisez des réinitialisateurs synchrones pour éviter les états initiaux aléatoires qui peuvent causer des latences supplémentaires pendant le démarrage.
  • Éviter la logique combinatoire sur les signaux d'activation qui pourraient créer des problèmes.
  • Préférence aux implémentations DSP fournies par le fournisseur[ sur les multiplicateurs de tissu pour la vitesse et la latence. La tranche DSP48E2 peut, par exemple, effectuer une accumulation multiple en 2 cycles (y compris les registres de pipelines).
  • Lorsque vous utilisez le bloc RAM pour les coefficients, faites le pipeline de l'adresse et des sorties de données pour éviter d'ajouter une latence supplémentaire.
  • Simulez avec un jeu réaliste sur l'horloge pour assurer des marges de timing. Des outils comme Intel analyseur de timing[ fournissent une estimation précise.
  • Retempsr la conception après synthèse en utilisant des fonctions de retiming d'outil, mais vérifier que le retiming n'a pas augmenté le nombre global de cycles en insérant des registres inutiles.

Conclusion

En choisissant le type de filtre approprié (généralement FIR), en appliquant la pipeline agressive et la parallélisation, et en tirant parti des blocs dédiés à la DSP, les ingénieurs peuvent obtenir des latences inférieures à 100 ns, même pour des réponses complexes aux filtres. Les techniques décrites dans cet article, allant de l'insertion de pipelines de base aux réseaux systoliques avancés, fournissent une trousse pratique aux concepteurs de VHDL ciblant les systèmes de traitement de données de pointe. Vérifiez toujours la latence par simulation et analyse statique du timing et traitez le retard des signaux de contrôle avec la même rigueur que les chemins de données.

Pour plus de détails sur les implémentations de filtres VHDL et l'optimisation de FPGA, voir des ressources telles que FPGA4Fun tutorials et des notes d'application de fournisseur.