c a OP b Digitalteknik och Datorarkitektur 5hp ALU Design Principle 1 - Simplicity favors regularity add $15, $8, $11

Transkript

1 A basic -bit Select between various operations: OR, AND, XOR, and addition Full Adder Multiplexer Digitalteknik och Datorarkitektur hp Föreläsning : introduktion till MIPS-assembler - april 8 karlmarklund@ituuse Jisses Vi börjar redan få koll på hur vi skulle kunna bygga en - bitars Each register can store bits Input must be in one of these registers a b MIPS is a Register-toregister architecture Once an is designed, we need to define how it interacts with the rest of the processor Output must go back to a register c The Von Neuman Model (Stored Program Computer): Data and Instructions both stored in memory c a b add c, a, b Alternativ notation för c a + b Design Principle - Simplicity favors regularity add $, $8, $ Vi anger med $n vilket register vi menar Detta är ett första exempel på en instruktion skriven i MIPS-assembler Genom en enkel design blir det lättare att få saker och ting att påminna om varandra

2 add $, $8, $ $ = $8 + $ Verkar vettigast att följa samma mönster när vi definierar subraktion Självklart är det bra om vi kan kolla om saker är lika, till exempel om a == b sub $, $8, $ $ = $8 - $ Ok, nu kan vi addera och subtrahera Favors Simplicity Operander måste hämtas från register och resultat måste skrivas tillbaka till något register Regularity Det blir naturligt att olika instruktioner påminner om varandra A simple -bit comparator seq $, $8, $ A B A == B A XOR B NOT (A XOR B) lika olika olika lika $8 $ Set EQual Räcker om en input är, dvs ett bitpar är olika så ger NOR-grinden, dvs hela talet är olika Set to if content of $8 is equal to content of $, othervise set to $ Även denna instruktion följer samma mönster Varför finns det endast st register? Design Principle : Smaller is faster $8 $ $

3 Logic needed here to select registers Det har alltså sina fördelar att vara liten En MIPS-instruktion i närbild bits bits bits bits bits bits register a bit register b bit Registers bit bit op rs rt rd shamt funct bits add $, $7, $8 register c bit bit Med fler register behöver vi fler bitar här mer logik tar mer plats och går långsammare op rs rt rd shamt funct R-type Design Principle : Make the common case fast bits bits bits bits Add Immediate addi $, $8, 77 bits addi $, $8, 77 Det är vanligt att man vill addera konstanter I detta fall adderas 77 till innehållet i register $8 och resultatet lagars i register $ Inte samma -kod som add I-type Hur uppstår data i registren från första början? register a bit register b bit register c bit Registers bit bit bit Minnet består av celler Varje cell har en unik adress En adress består av bitar I det hexadecimala talsystemet kan vi skriva -bitars tal med 8 hexadecimal siffror Address Content xffffffff xfffffffe xfffffffd xfffffffc x x x x Varje cell i minnet kan lagra åtta bitar, dvs en byte Fyra bytes bildar ett ord (word) om bitar

4 A Ett Ord B C D Intel x8, SPARC och Power PC använder little endian Big Endian: ett ord adresseras med adressen till den mest signifikanta byten Little Endian: ett ord adresseras med adressen till den minst signifikanta byten SPARC och MIPS använder big endian A Ett Ord B C D Vi antar att vi lagrat adressen x I register $8 lw $, ($8) Load Word Denna instruktion hämtar ordet på adress x och lagar det i register $ Address Content xffffffff xfffffffe xfffffffd xfffffffc x7 x x x x x x x Vi antar att vi lagrat adressen x I register $8 Address xffffffff Content Vi antar att vi lagrat adressen x I register $8 Address xffffffff Content xfffffffe xfffffffe lw $, -($8) xfffffffd xfffffffc sw $, ($8) xfffffffd xfffffffc Vi kan ange ett offset x7 Store Word x7 Denna instruktion hämtar ordet på adress: x - x = x och lagar det i register $ x x x x x Denna instruktion sparar innehållet i register $ på adress x x x x x x x x x x Design principle Good design demands good compromises Hittils har alla instruktioner haft lika många fält (regularity) lw $, ($8) Det är dock mycket vanligt att man behöver addera och subrahera konstanter, till exempel i = i + ; sw $, ($8) För att kunna hantera vanliga fall med konstanter får vi på samma sätt som vid konstruktionen av denna ligga-och-cykla-maskin kompromissa med våra tidigare principer I-type

5 SPIM är en simulator för MIPS Här ser vi innehållet i registren SPIM finns för förutom för Windows även för Unix/Linux Här ser vi innehållet i minnet Här ser vi instruktionerna i det program som körs MIPS delar upp minnet på följande sätt Här lagras data som programmet behöver first_trys En ettiket (label) är ett sätt att referera till en rad i programmet, dvs till en address i minnet main: text globl main addi $t, $zero, addi $t, $zero, add $t, $t, $t Ett direktiv som berättar för assemblatorn att det som följer skall tolkas som ett program Assemblator översätter varje rad till en maskininstruktion och lagrar dessa i text-segmentet i minnet För att SPIM skall veta vart programmet börjar måste det finnas en ettiket med namn main som även deklareras som global seq $t, $t, $t seq $t, $t, $t Här ligger maskinkoden för programmet jr $ra Nur prövar vi att köra programmet i SPIM I Windows kan vi steppa en instruktion i taget genom att trycka på tangent F I Linux/Unix kan vi steppa en instruktion i taget genom att klicka på denna knapp

6 Maskinkod: x8 Det speciella registret PC (program counter) anger vilken instruktion som skall utföras Här ser vi adressen för varje instrukton Hexadecimalt x x8 x x Decimalt * = 8* * = 8 * = Binärt Här ser vi hur maskinkoden för varje instruktion ser ut ( bitar 8 hexadecimala siffror) Register Register 8 En konstant: -kod för addi aha en I-type instruktion! Aha addi $8, $, to_and_from_memorys Genom att skapa ettketter här kan vi använda dessa för att referera till dessa addresser i datasegmentet senare data x: word y: word z: space text globl main main: la $t, x lw $t, ($t) lw $t, y add $t, $t, $t la $t, z sw $t, ($t) sw $t, ($t) addi $t, $t, sw $t, z jr $ra Ett direktiv som berättar för assemblatorn att det som följer skall tolkas som data och lagras i datasegmentet Här använder vi oss av etiketten x som vi definierat tidigare Genom att skapa ettketter här kan vi använda dessa för att referera till dessa addresser senare Load Address Assemblator vet vilken adress i minnet som etiketten x motsvarar Denna adress läggs i register $t data x: word y: word z: space text globl main main: la $t, x lw $t, ($t) lw $t, y add $t, $t, $t la $t, z sw $t, ($t) motsvarande maskininstruktion sw $t, ($t) addi $t, $t, motsvarande maskininstruktion sw $t, z eller jr flera riktiga $ra maskininstruktioner Ett direktiv som berättar för assemblatorn att vi vill lagra talet som ett ord i datasegmentet Ett direktiv som berättar för assemblatorn att vi vill reservera plats för fyra byte i datasegmentet Det går att använda etiketter direkt tillsammans med Loadoch Store Word Notera dock att även detta självklart är att betrakta som en pseudo-instruktion, dvs det finns ingen Detta är en så kallad pseudo-instruktion, dvs det finns ingen Assemblatorn kan dock översätta pseudoinstruktioner till en Nur prövar vi att köra programmet i SPIM Ser bekant ut nämen är det inte vårt x = och y = Sen följer ett nollat ord, det måste vara z