Welk coderingstype moet ik gebruiken? Voorbeeld FPGA-toepassingen

Volg drie experimenten die het proces laten zien om te bepalen welk type codering bij een bepaalde FPGA past.

Welk coderingstype moet ik gebruiken voor mijn FPGA? Zoals ik in het vorige artikel heb besproken, beslist een compiler dit over het algemeen voor u - en ik raad u aan te volgen wat de compiler beslist.

Het is echter belangrijk om de verschillen tussen de soorten codering te begrijpen en waarom een ​​compiler tot een bepaalde conclusie zou kunnen komen. Met dat in gedachten zal dit artikel u door een experiment leiden waarin een voorbeeld van een FPGA-toepassing wordt getoond en stap voor stap wordt besproken welk coderingstype het beste is.

Tot nu toe hebben we in deze serie besproken hoe je een finite state machine (FSM) kunt maken met Verilog, de initiële status en hoe geheugen de FPGA-codering beïnvloedt, en een overzicht op hoog niveau waarin binaire versus one-hot versus grijze codering wordt vergeleken .

Het te testen systeem

Voor dit experiment wilde ik een groot aantal keren een toestandsmachine instantiëren om de verschillen in de resulterende hardware te vergroten wanneer binaire, grijze en one-hot-coderingen worden gebruikt.

Het systeem dat ik uiteindelijk heb gekozen, is Conway's Game of Life, een cellulaire automaat die het gedrag van levende cellen in hun omgeving simuleert, een rechthoekige 2D-array van cellen. Conway's Game of Life is een simulatie van het ontstaan, reproduceren en sterven van deze cellen, volgens een eenvoudige set regels die elke cel volgt om te bepalen wat er in de volgende cyclus gebeurt. Elke levende cel kan overleven of sterven, en elke dode cel kan dood blijven of levend worden. Dit zijn de regels voor elke cyclus:

1. Levende cellen met twee of drie levende buren overleven.
2. Dode cellen met drie levende buren komen tot leven.
3. Alle andere cellen gaan dood of blijven dood.

Deze regels creëren veel interessant gedrag en patronen die op grote schaal zijn bestudeerd in de informatica.

Dit is hoe Conway's Game of Life eruitziet bij het uitvoeren van wat bekend staat als een enkel Gosper's glider-kanon.

Een variatie op Conway's Game of Life, bekend als Bill Gosper's Glider Gun. Gif gemaakt door Lucas Vieira [CC BY-SA 3.0]

Verilog-code

Terug naar ons testsysteem:elke cel was ontworpen als een toestandsmachine met acht toestanden. Toegegeven, de logica voor een cel in Conway's Game of Life kan in één cyclus worden opgelost, maar ik besloot een machine met 8 toestanden te maken om een ​​opmerkelijk verschil te hebben bij het gebruik van verschillende coderingen. De toestanden worden gebruikt om de levende buren van een cel te tellen.

Het volgende stukje Verilog-code toont de celmodulestructuur voor deze machines, inclusief de originele binaire codering van toestanden.

`define STATE_0 3'b000

`define STATE_1 3'b001

`define STATE_2 3'b010

`define STATE_3 3'b011

`define STATE_4 3'b100

`define STATE_5 3'b101

`define STATE_6 3'b110

`define STATE_7 3'b111

module LifeCell(

invoer clk,

nrst invoeren,

invoer zaad,

invoer [7:0] buren,

output reg actief);

reg [2:0] staat;

altijd @ (posedge clk)

if (nrst ==0)

staat <=`STATE_0;

anders

zaak(staat)

`STATE_0:begin

// ...

staat <=`STATE_1;

einde

`STATE_1:begin

// ...

staat <=`STATE_2;

einde

// ...

`STATE_7:begin

// ...

staat <=`STATE_1;

einde

eindgeval

eindmodule

Als je de code van dichterbij wilt bekijken, kun je het project op GitHub bekijken.

FPGA-coderingsimplementaties

Het systeem werd gesynthetiseerd en geïmplementeerd als een wereld van 23x23 cellen, in totaal 27 varianten:er werden drie verschillende FSM's gebruikt, allemaal met de drie bovengenoemde coderingen, allemaal op drie verschillende doel-FPGA's.

FSM #1:origineel model

Deze machine heeft een beginstatus die één keer wordt uitgevoerd en vervolgens in een cyclus door de resterende zeven statussen loopt. Dit is bijna een volledige reeks, dus Gray-codering leek me aanvankelijk veelbelovend.

FSM #2:Een reeks

Deze machine gedraagt ​​zich als een 3-bits teller, dus ik verwachtte ook dat Gray-codering de concurrentie zou verpletteren.

FSM #3:een willekeurige wirwar

Deze machine heeft hetzelfde kritieke pad als FSM #1, maar het gaat door een willekeurig pad wanneer bekend is dat het aantal levende buren groter is dan 3.

Voor dit willekeurige toestandsovergangsgedrag verwachtte ik dat one-hot codering de beste keuze zou zijn.

Doelarchitecturen

Het systeem is geïmplementeerd voor drie doel-FPGA's, met behulp van de ontwikkelingstool van hun leverancier:

• Xilinx Vivado Suite, voor een Artix 7 FPGA
• Intel Quartus Prime, voor een Cyclone V FPGA
• Lattice Diamond, voor een LatticeXP2 FPGA

De resultaten vergelijken

Het vergelijken van de prestaties van twee of meer systemen is moeilijk, vooral omdat het oordeel afhangt van de metrische gegevens die we gebruiken en welke aspecten we belangrijker vinden dan andere. Voor dit experiment heb ik de volgende gegevens verzameld om een ​​score voor elke implementatie te maken:

• Aantal logische eenheden. Dit zijn LUT's (opzoektabellen) voor Xilinx en Lattice FPGA's, of ALM's voor Intel FPGA's. Score:1 punt.
• Aantal registers. Score:1 punt.
• Geschatte maximale frequentie. Score:2 punten.
• Geschatte On-Chip Power. Score:2 punten.

Voor elke implementatie werden deze vier aspecten vergeleken tussen de drie coderingen, dus van de coderingen kreeg ik een beste, een slechtste en een middelste resultaat:de beste krijgt zijn positieve score, de slechtste krijgt zijn negatieve score en de middelste krijgt 0.

Nadat ik alle scores voor elk model had opgeteld, kreeg ik de volgende resultaten:

Resultatentabel voor alle 27 implementaties. In elke rij wordt de beste codering weergegeven in groen, de slechtste in rood en de middelste in geel als er geen banden zijn.

Dit lijkt te suggereren om weg te blijven van one-hot codering, met slechts twee gevallen waarin het wint, waarvan er één een gelijkspel is. Bovendien, hoewel ik aanvankelijk verwachtte dat one-hot de beste codering voor FSM-model #3 zou zijn, bleek het de slechtste codering te zijn, zonder dat een ontwikkelingstool het aanbeveelt. Dat gezegd hebbende, er zijn gevallen waarin de een de rest verslaat, meestal in de frequentie- en vermogensstatistieken.

Over het algemeen lijkt grijze codering de beste keuze voor dit specifieke systeem.

Als we de winnaars uit deze tabel halen, krijgen we het volgende:

Het vonnis

Hoewel deze vergelijking Gray-codering lijkt te prefereren boven binair en one-hot, zijn de resultaten sterk afhankelijk van de statistieken die we gebruiken, en deze statistieken weerspiegelen wat belangrijk voor ons is. In deze vergelijking vond ik bijvoorbeeld frequentie en vermogen belangrijker dan gebruik (het aantal logische elementen en registers in het ontwerp). Als ik gebruik had gewaardeerd boven frequentie en frequentie boven vermogen, zou er zeker een andere rangorde zijn ontstaan.

Deze vergelijking was niet bedoeld als een definitief werk over de prestatie die werd verkregen door het gebruik van deze coderingen. In plaats daarvan toont het de rangorde die wordt geproduceerd door mijn persoonlijke voorkeuren in de architecturen die ik heb gebruikt.

Nogmaals, als je de code wilt bekijken, de 27 implementaties wilt bekijken of mijn simulatie van Conway's Game of Life in actie wilt zien, bekijk dan het project op GitHub.