Articles

Wat is een accumulator?


Beste antwoord

Een accumulator is een object dat incrementeel sommen bijhoudt, tellingen die nodig zijn voor een efficiënte berekening van gemiddelden, standaarddeviatie, minuten , max enz. in plaats van elke keer opnieuw te moeten berekenen.

Antwoord

Laat me je vraag een beetje verfijnen: Wat is het verschil tussen een architectuur van een accumulatorinstructieset en een architectuur voor een algemene registerinstructieset?

Deze vertegenwoordigen twee punten in de ontwerpruimte voor instructiesets. Bedenk wat een CPU-instructie moet doen. Overweeg voorlopig reken instructies. Het moet minimaal de volgende informatie bevatten:

  • Welke berekening moet worden uitgevoerd (optellen, aftrekken, verschuiven, vergelijken)
  • Op welke waarden moet de berekening worden uitgevoerd ( de invoer voor de berekening)
  • Waar moet ik het resultaat plaatsen (de uitvoer van de berekening)

Bijvoorbeeld, als ik de programma-instructie op hoog niveau X = Y + Z, moet u de processor vertellen om de waarden in Y en Z op te halen, ze toe te voegen en het resultaat naar X te schrijven.

In een accumulatorarchitectuur moeten de meeste berekeningsinstructies werken op een speciaal register dat de accumulator wordt genoemd. De meeste bewerkingen hebben daarom de accumulator als een impliciet argument voor de instructie. De accumulator levert ofwel een input voor de instructie, ontvangt de output van de instructie, of beide. Om X = Y + Z uit te voeren op een op een accumulator gebaseerde machine, zou de instructiesequentie er ongeveer als volgt uitzien:

  • Laad Y in de accumulator
  • Voeg Z toe aan de accumulator
  • Sla accumulator op in X

Als ik een complexere uitdrukking had, zoals “I = J + K + L + M + N + O “, zou de reeks er als volgt uit kunnen zien:

  • Laad J in de accumulator
  • Voeg K toe aan de accumulator
  • Voeg L toe aan de accumulator
  • Voeg M ​​toe aan de accumulator
  • Voeg N toe aan de accumulator
  • Voeg O toe aan de accumulator
  • Sla accumulator op in I

Omdat de meeste bewerkingen betrekking hebben op de accumulator, hoeft u “geen opcode-bits te gebruiken om deze te specificeren. Zoals ik al eerder zei, is de accumulator impliciet . Ook in de machine zelf kan de accumulator rechtstreeks in de rekeneenheid zelf worden ingebouwd, waardoor de hardware wordt vereenvoudigd.

In een registerarchitectuur voor algemeen gebruik, rekeninstructie s nemen meerdere argumenten om aan te geven uit welke registers waarden moeten worden gelezen. Dit maakt ze flexibeler. Maar de flexibiliteit brengt kosten met zich mee: je hebt meer opcode-bits nodig om aan te geven op welke registers je wilt werken, en je moet paden voor al die registers naar de rekeneenheid geven.

Voor de voorbeelduitdrukkingen hierboven , ziet de code er niet veel anders uit:

  • Laad Y in register R0
  • Laad Z in register R1
  • Voeg R0 toe aan R1, het resultaat in R2
  • Sla R2 op in X

Registermachines voor algemeen gebruik beginnen een voordeel te vertonen als je waarden in registers kunt bewaren voor vele bewerkingen. Stel dat ik dit iets gecompliceerder programma wil uitvoeren:

X = A + B

Y = A - B

In een accumulatormachine zou ik A en B opnieuw moeten laden voor beide bewerkingen. In een machine voor algemeen gebruik laad ik A en B slechts één keer.

Binnen registermachines voor algemeen gebruik zijn er ook meerdere varianten: (Deze lijst is niet uitputtend; ook combineren sommige architecturen deze concepten. )

  • Register-geheugen: één operand komt uit een register en één operand komt uit het geheugen.
  • Register-Register, 2-adres: beide operanden komen uit registers, maar het resultaat moet een van de ingangen overschrijven.
  • Register-Register, 3-adres: beide operanden komen van registreert, en het resultaat kan naar zijn eigen register gaan.

De x86-processor is bijvoorbeeld een Register-Memory-machine die ook 2-adres Register-Register-instructies biedt. De meeste RISC-machines zijn Register-Register-machines met 3 adressen, met aparte laad- / opslaginstructies. Beide zijn algemene registermachines.

Vergelijk deze met de 6502 , die een accumulatormachine is. De meeste rekenkundige bewerkingen (optellen, aftrekken, roteren en verschuiven) werken op het A-register. De twee andere registers, X en Y, ondersteunen alleen verhogen, verlagen en vergelijken; ze “worden voornamelijk gebruikt voor het indexeren van geheugen en lustellers.

Een derde architectuurtype dat je niet” noemde, is de stack-architectuur . Een stapelarchitectuur is vergelijkbaar met een accumulatorarchitectuur doordat alle berekeningen op een enkel punt zijn gericht. Het verschil is dat een stapelarchitectuur altijd zijn argumenten van een stapel leest en zijn resultaten altijd op de stapel plaatst.Zowel de invoer en de uitvoer van een rekeninstructie zijn impliciet. Andere instructies moeten dan het pushen van waarden naar en popping van waarden van de stapel beheren.

Je vindt niet veel stapelarchitecturen in echte chips. Maar ze zijn populair in tolken (Java-bytecode, bijvoorbeeld , of FORTH), en in bepaalde rekenmachines zoals HPs RPN-gebaseerde rekenmachines.

Geef een reactie

Het e-mailadres wordt niet gepubliceerd. Vereiste velden zijn gemarkeerd met *