Laboration 1

Namn:
Laborationen godkänd:
Laboration 1.
MIPS-processorn, maskinspråk och assemblerprogrammering
Laborationens syfte
I denna laboration ska du bekanta dig med programutvecklingsmiljön och processorns instruktioner.
Laborationen går igenom hur assemblerspråket är konstruerat och hur det används.
Detta är nödvändigt för att förstå de kommande laborationerna.
Efter laborationen kommer du att förstå hur datorn exekverar enkla instruktioner
och hur instruktioner och data lagras i minnet.
Förberedelser:
Läs i Brorssons bok kap. 4 och Appendix D
Läs igenom laborationen noggrant och gör ett lösningsförslag till hemuppgiften.
Den kräver en hel del arbete. Du måste själv kunna redovisa hur din lösning fungerar.
Stefan Nyman
22 september 2010
Hemuppgift 1
Studera nedanstående lilla program och förklara hur det fungerar!
Den första raden är en kommentarrad. Den inleds alltid med tecknet #.
De fyra efterföljande raderna består av direktiv som bestämmer hur programmet
ska översättas av assemblern.
De tre följande raderna är programmets verkliga instruktioner. Förklara med hjälp
av läroboken vad dessa instruktioner betyder och vad programmet i sin helhet utför.
Observera att instruktionen li $8, 0x2 är en s.k. syntetisk instruktion som kommer att ersättas av instruktionen addiu $8, $0, 0x2 innan den översätts till maskinkod. Glöm inte att i fortsättningen alltid kommentera dina programrader; du
har mycket nytta av det senare.
# Laboration 1, Hemuppgift 1
start:
.set noreorder
.text
.globl start
.ent start
#
#
#
#
#
li
$8, 0x2
# .............................
li
$9, 0x3
# .............................
add
$10, $8, $9 # .............................
.end start
Ändra inte instruktionernas ordning
Instruktioner skapas
”start” är en global symbol
Programmet börjar vid ”start”
Dina kommentarer:
# Markerar slutet på programkoden
2
Datorarkitekturer och operativsystem, Lab 1
22 september 2010
Hemuppgift 2
Följande assemblyprogram avläser läget på 8 omkopplare och styr 8 lysdioder. Först
laddas register $9 med 0xbf900000, adressen till inporten (där omkopplarna är anslutna). Sedan läser programmet 8 bitar från inporten där varje bit motsvarar läget
på en av omkopplarna. Detta värde skrivs sedan tillbaka till utporten, som faktiskt
har samma adress (Hur kan den ha det?). Allt detta repeteras om och om igen.
# Laboration 1, Hemuppgift 2
.set noreorder
.text
.globl start
.ent start
start:
lui
repeat: lbu
nop
sb
b
nop
$9, 0xbf90
# Övre halvan av portadressen
# Undre halvan nollställs
$8, 0x0($9) #
#
$8, 0x0($9) #
repeat
#
#
.end start
Läs från inporten
Behövs efter en load
Skriv till utporten
Om och om igen
Behövs efter en branch
# Markerar slutet på programkoden
Översätt detta program till hexadecimal form. Observera att instruktionen
b repeat
utförs av instruktionen
beq $0, $0, repeat.
Varför?
Instruktionerna lbu och b måste följas av instruktionen nop som representeras av
nollor. Anledningen till detta kommer du att inse i en senare laboration.
3
Datorarkitekturer och operativsystem, Lab 1
22 september 2010
Programutvecklingsmiljön
Alla program du behöver finns på skolans nätverk och även på webben att ladda
hem till din egen dator.
Du hittar programmen på:
Student/mipsit/bin
För denna laboration behöver du
• MipsIt.exe (för programutvecklingen) och
• Mips.exe (för simuleringen)
Det kan vara praktiskt att skapa genvägar till dessa två program.
De två programmen MipsPipeS och MipsPipeXL kommer att användas i en kommande laboration.
Mips.exe måste vara igång innan man laddar upp koden till simulatorn.
Tänk på följande:
•
•
•
•
Spara alla dina filer i en egen hemmakatalog, exempelvis H:\Datorarkitekturer\
Skapa en ny projektfil för varje nytt program.
Spara det gamla projektet innan du skapar ett nytt.
Programmen har några år på nacken så undvik att använda mellanrum och
konstiga tecken i mappar och filnamn.
4
Datorarkitekturer och operativsystem, Lab 1
22 september 2010
Ett litet enkelt program
Instruktionerna på maskinkodsnivå är programmets enklaste delar. De kan naturligtvis kombineras för att kunna utföra mer komplexa uppgifter. Här ser du en del
av programmet i hemuppgift 1. Dessa rader är just den del av programmet som genererar maskinkod vid kompileringen.
start:
li
li
add
$8, 0x2
#
$9, 0x3
#
$10, $8, $9 #
Programmet utför additionen 2 + 3 = 5. Först laddas värdet 2 i register $8, sedan
laddas talet 3 i register $9 och slutligen adderas innehållen i dessa båda register och
resultatet läggs i register $10.
Namnet start utgör en symbol för en adress; det är användbart ifall man vill referera
till denna adress utan att känna till dess verkliga värde.
Uppgift 1
Starta MipsIt!
Under File – New skapar du ett nytt assemblerprojekt. Se gärna till att också en ny
mapp skapas med samma namn. Skapa en ny assemblerfil och skriv in koden enligt
hemuppgift 1.
Uppgift 2
Översätt programmet till maskinkod med kommandot Build eller snabbtangenten
F7. Blir det några fel, så får du besked om var det första felet finns. Rätta felen och
kompilera om programmet.
Uppgift 3
Starta MIPS.exe!
Ladda upp programmet till simulatorn. Enklast gör du detta med snabbtangenten
F5. Instruktionerna kommer att läggas i simulatorns RAM från adress 0x80020000.
Klicka upp Mips-simulatorn och klicka på rutan RAM. Här ser du nu det färdiga
programmet som det verkligen ser ut. Observera att instruktionen li nu är ersatt
med addiu.
5
Datorarkitekturer och operativsystem, Lab 1
22 september 2010
Uppgift 4
Öppna rutan CPU så du kan följa alla register. Stega sedan programmet med knappen med den blå pricken. Följ hur värdena ändras i registren när du stegar. Du kan
själv skriva in egna värden här.
Ett enkelt sätt att sätta PC till ett visst värde är att högerklicka på en viss rad och
sen välja ”Set Next Statement”.
Uppgift 5
Lägg till en branch-instruktion så att programmet blir en oändlig slinga. Efter
branch-instruktionen måste det finnas en NOP-instruktion. (Förklaring till detta
kommer i en senare laboration.)
Sätt en brytpunkt vid denna NOP-instruktion och kör programmet i full fart!
Ta bort brytpunkten och kör igen i full fart. Hur stoppar du programmet?
Kommunikation med omgivningen
Hittills har vi bara använt interna register.
Hemuppgift 2 läser från en inport och skriver till en utport. Portarna har samma
adress, 0xbf900000, och simuleras av en bild som föreställer omkopplare och
lysdioder.
Uppgift 6
Skapa ett nytt projekt, skriv in programmet i hemuppgift 2 och spara det i en ny fil.
Provkör programmet genom att stega det och undersök hur det fungerar.
Ändra på knapparnas positioner och studera vad som händer.
När du förstår hur programmet fungerar, kan köra i ”full” fart och manövrera
knapparna.
Uppgift 7
Ändra programmet så att varje nedtryckt knapp motsvaras av en släckt lampa; det
ska alltså fungera precis tvärtom mot den ursprungliga programversionen.
Leta rätt på en instruktion som du kan använda!
6
Datorarkitekturer och operativsystem, Lab 1
22 september 2010
Maskinkod
Följande assemblyinstruktion ska du för hand översätta till maskinkod:
addi
$8, $8, 0x1
Instruktionen adderar innehållet i register $8 med värdet 1 och lägger sen resultatet
i register $8.
Uppgift 8
Använd bokens appendix D för att fylla i det bitmönster nedan som motsvarar instruktionen.
I hexadecimal form:........................................
Uppgift 9
Här är en instruktion i binär form:
0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0
Skriv in koden i hexadecimal form i simulatorns minne på adress 0x80020000. Vilken instruktion är det?
..........................................................................
Simulatorns disassembler kan visa minnesinnehållet som heltal, flyttal. ASCIItecken eller instruktioner. Hur är de egentligen lagrade i minnet?
..............................................................................
Hur vet datorn att det lagrade bitmönstret är en instruktion?
..............................................................................
7
Datorarkitekturer och operativsystem, Lab 1
22 september 2010
Adresseringssätt
I instruktionen
addi
$8, $8, 0x1
finns ett värde inbyggt i själva instruktionen, dvs. 0x1. Detta kallas omedelbar adressering (immediate addressing).
Uppgift 10
Betrakta nu följande instruktion:
add
$8, $8, $9
Översätt instruktionen till maskinkod och skriv in den på nästa lediga adress.
I hexadecimal form:........................................
Kontrollera att den är rätt!
Lägg värdet 1 i register $8 och värdet 2 i register $9.
Utför instruktionen och kontrollera resultatet.
Vad finns i register $8? Varför?
……………………………………………………………………………………
Detta adresseringssätt kallas registeradressering.
Uppgift 11
Översätt följande instruktion till maskinkod:
lw
$8, 0x4($9)
8
Datorarkitekturer och operativsystem, Lab 1
22 september 2010
I hexadecimal form:........................................
Placera den i något ledigt utrymme.
Skriv in värdet 0x80020004 i register $9.
Utför instruktionen och förklara varifrån register $8 får sitt värde.
..............................................................................
Detta adresseringssätt kallas displacement addressing. En liknande adressering finns
hos AVR-processorn.
Det kan vara värt att hålla i minnet att MIPS-instruktionerna inte kan innehålla
större värden än 16 bitar. Vill man med instruktioner skriva in t.ex. värdet
0x80020004 i register $9, får man göra det i två steg:
lui
$9, 0x8002
ori
$9, $9, 0x4
Uppgift 12
Förutom då man läser eller skriver i minnet, behövs adresser vid hoppinstruktioner.
Adresserna kan då vara relativa, absoluta eller via register.
I uppgift 6 använde du ett program med en oändlig loop.
Studera maskinkoden och ange hur maskinkoden för följande instruktion ser ut:
loop:
b
loop
op = ........
rs = ........
rt = ........
label = ........
9
Datorarkitekturer och operativsystem, Lab 1
22 september 2010
Instruktionsomflyttning
Nedanstående program har du sett i hemuppgift 2.
Eftersom MIPS-processorn har en pipeline-arkitektur, kommer instruktioner som
står direkt efter hoppinstruktioner alltid att exekveras innan själva hoppet görs.
Load-instruktioner har också en viss fördröjning eftersom det behövs en extra
klockcykel för att få in värdet till destinationsregistret.
Detta är anledningen till att en nop-instruktion har placerats efter instruktionerna
lbu och b. Pipelining kommer att förklaras närmre i en senare laboration.
.set noreorder
.text
.globl start
.ent start
start:
lui
repeat: and
lbu
nop
sb
b
nop
$9, 0xbf90
# Övre halvan av portadressen
# Undre halvan nollställs
$8, $0, $0 # Nollställ register 8
$8, 0x0($9) # Läs från inporten
# Behövs efter en load
$8, 0x0($9) # Skriv till utporten
repeat
# Om och om igen
# Behövs efter en branch
.end start
# Markerar slutet på programkoden
Uppgift 13
Assemblatorn kan ordna om instruktionerna eller placera in nop-instruktioner automatiskt om det behövs. Skriv in, kompilera och ladda upp ovanstående kod till
simulatorn.
Observera att det är nästan exakt samma kod som i hemuppgift 2!
Stega igenom programmet försiktigt så du förstår vad varje instruktion utför.
Uppgift 14
Ta bort (eller kommentera bort) de rader där instruktionen nop finns.
Kontrollera koden som skapas och provkör. Beter det sig på samma sätt nu?
Om inte, vilken är skillnaden?
10
Datorarkitekturer och operativsystem, Lab 1
22 september 2010
....................................................................................
Varför blir det på detta viset?
....................................................................................
Uppgift 15
Ta nu bort raden (eller kommentera bort den):
.set noreorder
Provkör igen! Hur fungerar programmet nu? .......................................................
Jämför med den ursprungliga versionen.
Skriv här den programversion som skapades:
....................................................................................
....................................................................................
....................................................................................
....................................................................................
....................................................................................
....................................................................................
Vad skiljer denna version från den som skapades i uppgift 13?
……………………………………………………….
11
Datorarkitekturer och operativsystem, Lab 1
22 september 2010