Een FIFO is een First In First Out -geheugen. U kunt zich voorstellen dat gegevens aan het ene uiteinde worden verschoven en aan de andere kant worden verschoven, waarbij de hoeveelheid gegevens in de FIFO een maximumlimiet kan bereiken.

Het feitelijk verschuiven van gegevens in het geheugen is echter duur om te doen in hardware. Een betere manier is om een ​​geheugen normaler te gebruiken, maar het te laten lijken op een circulaire buffer door het volgende adres te manipuleren om naar te schrijven en van te lezen. Deze adressen leven in aparte registers en worden vaak de leeswijzer en de schrijfwijzer genoemd.

Hier is een illustratie van de toestand voor een eenvoudige FIFO met een 8-woordgeheugen:

Het volgende inkomende woord wordt geschreven naar het lege woord op adres 1 (de waarde van de schrijfwijzer), en vervolgens naar de schrijfwijzer verhoogd tot 2. Het volgende leesverzoek haalt het woord op 5 (de waarde van de leeswijzer), daarna wordt de leeswijzer verhoogd met 1. In dit voorbeeld zijn de adressen automatisch cirkelvormig als de aanwijzers 3 bits breed zijn . Het toevoegen van 1 tot 7 levert 0 op in 3-bits ongetekende wiskunde.

Volledige FIFO-systemen hebben manieren nodig om de volledige en lege voorwaarden te identificeren. Hiervoor zijn verschillende schema's. Een apart register kan worden gebruikt om bij te houden hoeveel woorden er in de FIFO staan, namelijk 4 in de bovenstaande momentopname.

Een handig schema voor een firmware-implementatie is om de lees- en schrijfaanwijzers te vergelijken. Je zou bijvoorbeeld kunnen besluiten dat beide aanwijzers gelijk FIFO leeg is, en schrijf er een achter read (na wrapping) is FIFO vol. Merk op dat dergelijke schema's één woord van de FIFO ongebruikt laten. Je besteedt uiteindelijk een stukje staat ergens om detectie van vol en leeg mogelijk te maken, of dat nu een apart register is of een onbruikbaar woord in de FIFO. Het voordeel van dit schema is dat lezen en schrijven onafhankelijk en zonder conflicten kan gebeuren, dus zo'n FIFO heeft geen mutex nodig tussen lezen en schrijven. U hoeft interrupts bijvoorbeeld niet uit te schakelen tijdens het lezen, omdat er geen schade wordt toegebracht als een interruptroutine een woord naar de FIFO pusht terwijl de voorgrondcode probeert te lezen.

Olin's antwoord dekt het volledig.

Ik wil alleen maar toevoegen dat in digitale HW FIFO's vaak worden gebruikt om multi-bit data over te dragen tussen asynchrone klokdomeinen ( Clock Domain Crossing - CDC). Dit onderwerp is op dit moment misschien niet interessant voor je (het is nogal een gevorderd onderwerp), maar ik denk dat het volledig moet worden behandeld.

Deze speciale FIFO's worden asynchrone (asynchrone) FIFO's genoemd, en hoewel ze qua structuur vergelijkbaar zijn met basis-FIFO's, zijn er twee belangrijke toevoegingen:

• Lees- / schrijfopdrachten worden omgezet in grijze code voordat ze worden overgedragen tussen asynchrone klokdomeinen
• De geconverteerde waarden worden gesynchroniseerd met de klok van het bestemmingsdomein met behulp van synchronizers.

Dit schema zorgt ervoor dat multi-bit gegevens worden overgedragen zonder metastabiliteit problemen en het vermijden van datacorruptie als gevolg van onafhankelijke synchronisatie van bits.

Een logische structuur van async FIFO:

Een programmateller houdt de laatste instructie bij die in een programma is uitgevoerd. In een FIFO volgen de lees- en schrijfwijzers de laatste bit of byte die het laatst is gelezen of geschreven. Het zijn dus vergelijkbare concepten, maar voor verschillende dingen.

Het concept is niet zo moeilijk als je het jargon weghaalt. Als iemand u een lange lijst met nummers heeft gegeven en u heeft gevraagd ze op volgorde te lezen, kunt u uw vinger op de pagina plaatsen om uw plaats te helpen bepalen. Je vinger is een leesteller.