MIX är en hypotetisk dator som används i Donald Knuths monografi , The Art of Programming [ 1] . MIX:s datormodellnummer, 1009, kommer från en kombination av kommersiella maskinmodellnummer och namn som är samtida till den tid då boken skrevs och som verkade betydelsefulla för författaren. Dessutom är "MIX" lika med 1009 i det romerska siffersystemet .
1960-talets MIX har ersatts av en ny (också hypotetisk) datorarkitektur, MMIX , som kommer att ingå i en kommande upplaga av boken. Mjukvaruimplementationer av MIX- och MMIX-arkitekturerna har utvecklats av olika författare och är fritt tillgängliga (till exempel MIXware och MMIXware utvecklade av Knuth själv).
MIX är en hybrid binär decimaldator . När datorn är programmerad i binärt läge har varje byte 6 bitar (värden 0 till 63). I decimalläge har varje byte 2 decimaler (värden från 0 till 99). Byte är grupperade i ord med fem signerade byte. De flesta program skrivna för MIX kommer att fungera i både binärt och decimalläge så länge de inte försöker lagra ett värde större än 63 i en enda byte.
Ordet sträcker sig från −1.073.741.823 till 1.073.741.823 (inklusive) i binärt läge och från −9.999.999.999 till 9.999.999.999 (inklusive) i decimalläge. MIX-datorn skiljer mellan -0 och +0, vilket inte är fallet på moderna datorer, som bara har en representation av noll, men antalet negativa tal som kan representeras av ett visst antal bitar är en mer än antalet positiva siffror.
MIX-datorn har 9 register :
En byte antas ha minst 6 bitar. De flesta instruktioner kan specificera vilka av fälten (bytes) i ett register som behöver ändras med hjälp av ett suffix i formuläret (först:sista). Ett nollfält är ett enbitstecken.
MIX registrerar också om den föregående operationen orsakade ett spill och en av de tre indikatorerna (mindre än, lika med eller större än). I diagrammet nedan visas varje register uppdelat i sina egna fält.
|
|
|
|
|
|
|
|
|
|
|
MIX-datorn har 4000 ords lagringsutrymme (vardera 5 signerade byte) adresserbar från 0 till 3999. Dessutom finns det en mängd olika in- och utenheter:
Varje maskininstruktion i minnet upptar ett ord och består av 4 delar: adress (signerad 2 byte) i minnet att läsa eller skriva, indikering av indexregister (1 byte, som bestämmer vilket indexregister rI som ska användas) som ska läggas till adressen, modifiering (1 byte) som anger vilka delar av registret eller minnesplatsen som kommer att läsas eller modifieras, och op-koden (1 byte). Alla operationskoder har verbala beteckningar.
MIX-program använder ofta självmodifierande kod, särskilt för att återvända från en subrutin, eftersom MIX inte har en automatisk subrutinstack.
Program för MIX-datorn är vanligtvis skrivna på MIXAL- språket .
Ladda ner kommandon
Innehållet i fältet vid [ADDR + rIi(innehållet i register I med index i) ] laddas in i registret.
| LDA ADDR, i(0 : 5) | rA := minne[ ADDR + rIi ]; | ladda i A |
|---|---|---|
| LDX ADDR, i(0 : 5) | rX := minne[ ADDR + rIi ]; | ladda i X |
| LDi ADDR, i(0 : 5) | rIi := minne[ ADDR + rIi ]; | ladda in i I vid index i |
| LDAN ADDR, i(0 : 5) | rA := -minne[ ADDR + rIi ]; | ladda till A med omvänt tecken |
| LDXN ADDR, i(0 : 5) | rX := -minne[ ADDR + rIi ]; | ladda in i X med omvänt tecken |
| LDiN ADDR, i(0 : 5) | rIi := -minne[ ADDR + rIi ]; | ladda i I i med omvänt tecken |
Minnesskrivkommandon
Skriver innehållet i registret till minnesplatsen med adressen [ADDR + rIi]
| STA ADDR, i(0 : 5) | minne[ ADDR + rIi ] := rA; | Skriv en |
|---|---|---|
| STX ADDR, i(0 : 5) | minne[ ADDR + rIi ] := rX; | skriv X |
| STi ADDR, i(0 : 5) | minne[ ADDR + rIi ] := rIi; | skriv II |
| STJ ADDR, i(0 : 5) | minne[ ADDR + rIi ] := rJ; | skriv J |
| STZ ADDR, i(0 : 5) | minne[ ADDR + rIi ] := 0; | återställ cellinnehåll |
Aritmetiska kommandon
| LÄGG TILL ADDR,i(0 : 5) | rA := rA + minne[ ADDR + rIi ]; | tillägg |
|---|---|---|
| SUB ADDR, i(0 : 5) | rA := rA - minne[ ADDR + rIi ]; | subtraktion |
| MUL ADDR, i(0 : 5) | (rA, rX) := rA * minne[ADDR + rIi]; | multiplikation |
| DIV ADDR, i(0 : 5) | rA := int((rA, rX) / minne[ADDR + rIi]); rX := (rA, rX) % minne[ADDR + rIi]; |
division |
Adressoperationskommandon
| ENTA ADDR, dvs | rA:= ADDR + rIi; |
|---|---|
| ENTX ADDR,i | rX:= ADDR + rIi; |
| ÖNHN? ADDR, dvs | ri? := ADDR + rII; |
| ENNA ADDR, dvs | rA:= -ADDR-rIi; |
| ENNX ADDR, dvs | rX:= - ADDR - rIi; |
| ENN? ADDR, dvs | ri? := - ADDR - rIi; |
| INCA ADDR, dvs | rA:= rA + ADDR + rIi; |
| INCX ADDR,i | rX:= rX + ADDR + rIi; |
| I.N.C.? ADDR, dvs | ri? := ADDR + rII; |
| DECA ADDR i | rA:= rA-ADDR-rIi; |
| DECX ADDR, dvs | rX:= rX - ADDR - rIi; |
| DEC? ADDR, dvs | ri? := ri? - ADDR - rii; |
Jämförelsekommandon
| CMPA ADDR, i(0 : 5) | jämför rA med minne[ADDR + rIi ]; |
|---|---|
| CMPX ADDR, i(0 : 5) | jämför rX med minne[ADDR + rIi ]; |
| CMP? ADDR, i(0 : 5) | jämföra ri? med minne[ ADDR + rIi ]; |
Hoppa kommandon
| JMP ADDR, dvs | gå till ADDR + rii; |
|---|---|
| JSJ ADDR, dvs | gå till ADDR + rii; rJ förändras inte! |
| JOV ADDR, dvs | if (overflow) then overflow := false; gå till ADDR + rii; |
| JNOV ADDR, dvs | om (inget spill) så gå till ADDR + rIi; annars spill := falskt; |
| JL, JE, JG ADDR, i JGE, JNE, JLE ADDR, i |
om (mindre, lika, större) sedan gå till ADDR + rIi; om (inte mindre, ojämlikt, inte större) sedan gå till ADDR + rIi; |
| JAN/JAZ/JAP ADDR, jag JANN/JANZ/JANP ADDR, dvs |
om (rA < 0 eller rA == 0 eller rA > 0) så gå till ADDR + rIi; om (rA >= 0 eller rA != 0 eller rA <= 0) då gå till ADDR + rIi; |
| JXN/JXZ/JXP ADDR, i JXNN/JXNZ/JXNP ADDR, i |
om (rX < 0 eller rX == 0 eller rX > 0) så gå till ADDR + rIi; om (rX >= 0 eller rX != 0 eller rX <= 0) så gå till ADDR + rIi; |
| J?N/J?Z/J?P ADDR, i J?NN/J?NZ/J?NP ADDR, i |
om (rI? < 0 eller rI? == 0 eller rI? > 0) sedan gå till ADDR + rIi; om (rI? >= 0 eller rI? != 0 eller rI? <= 0) sedan gå till ADDR + rIi; |
Andra kommandon
| FLYTTA ADDR, i(F) | för(n = 0; n < F; n++, rI1++) minne[ADDR + rIi + n] := minne[rI1]; |
|---|---|
| SLA/SRA ADDR, i SLAX/SRAX ADDR, i SLC/SRC ADDR, i |
skift rA åt vänster/höger med ADDR+rIi byte skift (rA, rX) åt vänster/höger med ADDR+rIi byte rotera (rA, rX) åt vänster/höger med ADDR+rIi byte |
| NEJ | göra ingenting; |
| HLT | stoppa utförandet; |
I/O-kommandon
| I ADDR, i(F) | läs in ett block från ingångsenhet F till minnet[ADDR + rIi] och framåt; |
|---|---|
| OUT ADDR, i(F) | mata ut ett block till enhet F från minnet[ADDR + rIi] och framåt; |
| IOC ADDR, i(F) | skicka styrinstruktion till i/o-enhet F; |
| JRED ADDR, i(F) | om (i/o-enhet F är klar) så gå till ADDR + rIi; |
| JBUS ADDR, i(F) | om (i/o-enhet F är upptagen) så gå till ADDR + rIi; |
Konverteringskommandon
| NUM | rA := numeriskt värde för tecken i (rA,rX); |
|---|---|
| RÖDING | (rA, rX):= teckenkoder som representerar värdet på rA; |
| Donald Knuth | |
|---|---|
| Publikationer |
|
| programvara | |
| Teckensnitt |
|
| Kompetent programmering |
|
| Algoritmer |
|
| Övrig |
|