Verilog: Alignement d'octets valides et invalides à partir d'une entrée dynamique

J'essaie de concevoir un système qui prend une entrée de données de 8 octets et une entrée valide de 8 bits chaque cycle d'horloge où chaque bit de l'entrée valide valide ou invalide un octet de données.Verilog: Alignement d'octets valides et invalides à partir d'une entrée dynamique

input wire [63:0] d_in; 
input wire [7:0] v_in;

Le programme devrait traiter d_in en alignant tous les octets valides comme suit.

(où B est un octet valide et X est un octet non valide)

Instance 1:

d_in = B1 B2 X X B3 X B4 B5 

d_out = B1 B2 B3 B4 B5 X X X

Instance 2:

d_in = X B1 B2 B3 X B4 B5 B6 

d_out = B1 B2 B3 B4 B5 B6 X X

J'ai principalement travaillé avec des algorithmes avant où toute manipulation de bits était la même à chaque itération assign d_out [7:0] = d_in [15:8]; mais le fait que la quantité et l'ordre des octets valides puissent changer avec chaque entrée de données signifie que cette stratégie ne peut pas être utilisée.

Ma question:

Est-il possible de réaliser cette fonction en utilisant Verilog ou VHDL? Si oui, quelqu'un peut-il me diriger vers une solution de haut niveau ou une lecture pertinente afin que je puisse mieux comprendre ce concept. Je pense que si je comprenais à un niveau élevé, je serais capable de le coder mais actuellement je ne suis même pas sûr de ce que j'ai besoin de coder.

Merci Zach

Source

2017-02-18 Zach

Aïe! S'il n'y a vraiment pas de règle/motif défini et qu'il peut y avoir n'importe quel nombre d'octets à n'importe quelle position - alors vous finirez avec une logique assez profonde. Sachant cela, vous devriez utiliser la capacité de pipelining des FPGA pour pré-calculer certaines logiques imbriquées, en brisant la profondeur et en donnant un peu de temps pour les outils. Cela suppose que vous ne voulez pas mettre en tampon l'entrée et décaler les octets, mais ce ne serait pas non plus trivial. –

@fpga_magik Si cela ne vous dérange pas pouvez-vous développer ce que vous entendez par tampon le signal d'entrée et décaler les octets? Je suis intéressé par cette solution. Merci – Zach

Puisque vous a demandé de haut niveau, je vais donner un exemple de quelque chose qui pseudocode pourrait fonctionner, ou tout au moins vous y aller.

d_out = '0; //Assuming that the X bytes can be set to zero in the output. 
bytes = 0; 
for i in range(8) 
if v_in[i] 
    d_out[bytes*8 +: 8] = d_in[i*8 +: 8] //Note the +: notation which is not pseudo, but verilog. 
    bytes++

Maintenant, exécutez ce code séquentiel dans un bloc toujours et vous devriez être défini.

Note: Comment le résultat synthétisé de cet aspect ne me semble pas entièrement clair, mais je soupçonne qu'il va générer un peu de matériel.

Source

2017-02-20 14:45:49 Hida

Merci pour la contribution. Je comprends logiquement cette approche mais je crains qu'il y ait des problèmes de latence car il y a de nouvelles entrées de données à chaque cycle d'horloge et cette solution ne peut pas être pipelinée (à ma connaissance) – Zach

Vous avez raison de vous en préoccuper. Je soupçonne que la logique sera profonde. Cependant, il devrait être assez facile à mettre en œuvre, de sorte que vous pouvez lui donner un coup de balai et voir ce qui sort. En termes de pipelining, je ne pense pas que cette solution soit d'une grande aide. Mais une réflexion sur la fusion me vint à l'esprit. C'est-à-dire, sorte de tri par fusion, mais seulement en triant X octets à la fin du tableau d'octets. Je ne sais pas si c'est une solution viable. – Hida

Était en mesure de canaliser la solution d'origine en instanciant chaque itération de boucle en tant que module séparé avec des registres entre pour stocker les sorties de module afin de créer le pipeline. Il est méchant en termes de superficie, mais une conception efficace de la zone n'était pas une exigence car il fallait juste travailler fonctionnellement et répondre aux exigences de temps. Il y a certainement des solutions plus élégantes là-bas si – Zach

J'ai quelque chose de similaire mais pas tout à fait.

Entrer les données dans un FIFO, pré-calculer un octet-enable avec les entrées FIFO. Du côté de la sortie, lisez les parties d'activation des octets et utilisez-les pour décaler les octets. Donc, il n'y a que huit conditions pour satisfaire à l'octet permettre ...

1 byte, byteEn(0 downto 1) = "10", shift left 1 byte 
2 bytes, byteEn(0 downto 2) = "110", shift left 2 bytes 
3 bytes, byteEn(0 downto 3) = "1110", shift left 3 bytes

... et ainsi de suite ...

Comme vous passez, lu dans le mot suivant à l'aide des FIFOs de validation de lecture. Notez que vous devrez prendre soin lorsque le FIFO est vide mais pas arrêter le pipeline afin que les données déjà présentes continuent d'être décalées.

Je ne sais pas à quel point ce sera compliqué car je l'ai un peu passé en revue.

Source

2017-02-21 10:59:50

Verilog: Alignement d'octets valides et invalides à partir d'une entrée dynamique

Répondre

Questions connexes