NAR 2

NAR 2 ( Serbian Na stavni R ačunar 2, en. Educational Computer 2) är en teoretisk modell av en 32- bitars orddator skapad av Matematiska fakulteten vid universitetet i Belgrad professor Nedeljko Parezanović som en förbättring av sin föregångare, NAR 1 . Det användes för kurser i Assembly språk och datorarkitektur . Ordet "nar" betyder granatäpple på serbiska . Många NAR 2-simulatorer har skapats — till exempel fick en namnet "Šljiva" ( sv. plommon ) eftersom den frukten växer i Serbien , medan "nar" inte gör det.

Instruktionsstruktur

NAR 2- processorn använder 32-bitars maskinord. Varje maskininstruktion innehåller :

Register

NAR 2 har fyra register:

Mnemonics

Följande op-koder var tillgängliga (faktiska koder specificerades inte, bara minnesminnen):

Minnes-/registeråtkomst

  • MUA ( sr. M emorija U A kumulator , en. Memory Into Accumulator) laddar värdet i ackumulatorn
  • AUM ( sr. A kumulator U M emoriju , en. Accumulator Into Memory) lagrar innehållet i ackumulatorn
  • PIR ( sr. P unjenje I ndeksnog R egistra , en. Load Index Register) Laddar värdet i indexregistret

Heltalsaritmetik

Notera: alla mnemonics i denna grupp slutar med bokstaven "F" som indikerar "Fiksni zarez" ( sv. Fixed point) aritmetik. Detta gäller dock endast för addition, subtraktion och negation (teckenförändring). Multiplikation och division förutsätter att "punkten" är fixerad till höger om minst signifikanta bit - det vill säga att talen är heltal.

  • SABF ( sr. Sab eri u F iksnom zarezu , en. Add, Fixed Point) - lägger till parameter till ackumulatorn
  • ODUF ( sr. Odu zmi u F iksnom zarezu , en. Subtrahera, Fixed Point) - subtraherar parametern från ackumulatorn
  • MNOF ( sr. Mno ži u F iksnom zarezu , en. Multiplicera, Fixed Point) - Multiplicerar ackumulatorn med parametern
  • DELF ( sr. Del i u F iksnom zarezu , en. Divide, Fixed Point) - Delar ackumulatorn med parametern
  • PZAF ( sr. P romeni Z nak A kumulatora u F iksnom zarezu , sv. Ändra ackumulatorns tecken, fast punkt) - Ändrar (vänder) ackumulatorns tecken

Flyttalsräkning

  • SAB ( sr. Sab eri , en. Add) - lägger till parameter till ackumulatorn
  • ODU ( sr. Odu zmi , en. Subtrahera) - subtraherar parametern från ackumulatorn
  • MNO ( sr. Mno ži , en. Multiplicera) - Multiplicerar ackumulatorn med parametern
  • DEL ( sr. Del i , en. Divide) - Delar ackumulatorn med parametern
  • PZA ( sr. P romeni Z nak A kumulatora , sv. Ändra ackumulatorns tecken) - Ändrar (vänder) ackumulatorns tecken

Bitvis/logiskt

Obs: ovanstående operationer är alla bitvis . Deras namn antyder att de är rent logiska operationer men de kan förklaras som om de verkar på vektorer av bitar och separat tillämpa logiska operationer på varje par av bitar.

Logiska skiftningar

  • POL ( sr. Po meri L evo , en. Shift Left) - flyttar ackumulatorns bitar åt vänster
  • POD ( sr. Po meri D esno , en. Shift Right) - flyttar ackumulatorns bitar åt höger

Flödeskontroll

  • NES ( sr. Ne gatativni S kok , en. Negativt hopp) utför ett villkorligt hopp till adressen som anges av parametern om ackumulatorns nuvarande värde är negativt
  • BES ( sr. Be zuslovni S kok , en. Ovillkorligt hopp) utför ett ovillkorligt hopp till adressen som anges av parametern
  • NUS ( sr. Nu la- S kok , en. Zero Jump) utför ett villkorligt hopp till adressen som anges av parametern om ackumulatorns nuvarande värde är noll
  • ZAR ( sr. Za ustavi R ačunar , sv. Stoppa datorn) stoppar all ytterligare bearbetning; detta är den enda instruktionen som ignorerar parametern.

Standardsyntax för assemblerspråk

NAR 2-sammansättningsspråksyntaxen utformades för att vara enkel och lätt att tolka. Varje programrad kan innehålla upp till en instruktion specificerad enligt följande:

  1. Instruktionsmnemonik
  2. Whitespace, om instruktionen anger några indexregister, adresseringsläge eller en parameter och sedan kommaseparerad:
    1. Namn på indexregister, om det används
    2. Namn på flaggor för adresseringsläge (även kommaseparerade)
    3. Parametervärde

Exempelkod: 

   aum  X1, p, 0  mua  n, 1  aum  15  pir  X1, p, n, 1  mua  X1, p, n, 0  oduf  n, 1  oduf  X2, p, n, 0

Adresseringslägen

Med fyra adressmodsvalbitar (P, R, I och N - indexerade, relativa, indirekta och omedelbara), kan NAR 2-instruktioner specificera 16 olika adresseringsmoder men inte alla är meningsfulla i alla instruktioner. I följande tabell:

  • M[x] anger 32-bitarsvärdet (innehållet) för minnesplatsen x
  • BN anger programräknaren
  • p anger den 16-bitars signerade parametern på plats
  • Xi specificerar indexregistret som valts av data på plats
  • f() är funktionen "effektivt värde" som används för indirekt adressering (se detaljer nedan):
Addr. flaggor Instruktionstyp
P R jag N Data Hoppa
- - - - M[p] sid
- - - N sid sid
- - jag - M[f(M[p])] f(M[p])
- - jag N f(M[p]) f(M[p])
- R - - M[BN+p] BN+p
- R - N BN+p BN+p
- R jag - M[f(M[BN+p])] f(M[BN+p])
- R jag N f(M[BN+p]) f(M[BN+p])
P - - - M[Xi+p] Xi+p
P - - N Xi+p Xi+p
P - jag - M[f(M[Xi+p])] f(M[Xi+p])
P - jag N f(M[Xi+p]) f(M[Xi+p])
P R - - M[BN+Xi+p] BN+Xi+p
P R - N BN+Xi+p BN+Xi+p
P R jag - M[f(M[BN+Xi+p])] f(M[BN+Xi+p])
P R jag N f(M[BN+Xi+p]) f(M[BN+Xi+p])

Note 1: "N" (omedelbar) flagga har ingen effekt på hoppinstruktioner (flödeskontroll), eftersom processorn inte kan hoppa till ett specificerat värde, utan bara till en minnesadress.

Flernivåminne indirekt

NAR 2 stöder multi-level memory indirekt adresseringsläge. Platsen väljs först genom att "titta" på P (indexerade) och R (relativt programräknare) flaggor. Sedan, om I (indirekt) flagga detekteras, laddas ett 32-bitars ord från minnesplatsen som beräknats hittills och beräkningen startas om (inklusive alla adresseringslägesflaggor, indexregisterval och parametervärde - endast "opkoden" är utelämnad). Följande program, om det laddas på minnesplats 0 och körs:

mua I, 0; Minne-till-ackumulator, indirekt, från plats 0

... kommer att frysa NAR 2 i en oändlig adressberäkningsslinga:

  1. "I, 0" anger att den faktiska adressen ska laddas från minnesplats 0
  2. Minnesplats 0 är laddad. Det står "Jag, 0" igen
  3. "I, 0" anger att den faktiska adressen ska laddas från minnesplats 0
  4. Minnesplats 0 är laddad. Det står "Jag, 0" igen
  5. "I, 0" anger att den faktiska adressen ska laddas från minnesplats 0
  6. Minnesplats 0 är laddad. Det står "Jag, 0" igen
  7. ...

Anteckna det:

mua R, I, 0; Memory-Into-Accumulator, Relativ, Indirekt, från plats BN+0

verkar mer generiskt (kan frysa NAR 2 från vilken plats som helst), men detta beror på när BN-registervärdet ökas/ändras.

Frågan om behandling av "N" (omedelbar) flagga i närvaro av I (indirekt) flagga är öppen eftersom situationen är något tvetydig – det vill säga om flaggvärdet ska respekteras eller inte som anges i den ursprungliga instruktionen eller det i indirekt specificerad (uppslagen) adress leder till en konflikt. Tabellen ovan presenterar det första fallet som visar olika adresseringslägen som kan uppnås på detta sätt.

Läser värden från Indexregister

NAR 2 har instruktioner för att initiera värdet för ett särskilt indexregister ("PIR"-mnemonik). Den har dock inga särskilda instruktioner för att läsa värdeindexregister. Detta uppnås genom att använda flaggor för indexerad och omedelbar (P, N) adresseringsläge, som:

mua Xi, P, N, n; Minne-i-ackumulator, indexerad, omedelbar, 0

... vilket i huvudsak sätter Xi+n i ackumulator. För n=0 förvandlas detta till en "ladda indexregistervärde till ackumulator"-instruktion.

Se även

  • NAR 1
  • MMIX , ​​en annan processor designad av en professor för att hjälpa elever att lära sig.

externa länkar

Hämtad från " https://en.wikipedia.org/w/index.php?title=NAR_2&oldid=1024739988 "