Datorarkitekturer med operativsystem ERIK LARSSON

Översikt Processorn Maskininstruktioner

Dator Primärminne Data/instruktioner Kontroll Central processing unit (CPU) Fetch instruction Execute instruction

Användarprogram, OS och hårdvara Applikationsprogram, t ex Word, Facebook, är ofta skrivna i ett högnivåspråk, t ex C, C++. System programvara Kompilatorer: Översätter program i högnivåspråk till maskinspråk Operativsystem: Hårdvara» Hantera I/O, minne och schemaläggning av jobb (tasks) Processor, minne, I/O-kontrollenhet

Program Abstraktionsnivå: Högnivåspråk Assemblyspråk Maskinspråk

Register Primärminne Instruktioner och data Data/instruktioner Kontroll Central processing unit (CPU) Register Fetch instruction Execute instruction

Register Alla processorer har någon form av register fil för att temporär lagra operander MIPS har en 32x32-bitars registerfil Används för data som används frekvent Numreras 0 till 31 32-bitars data kallas ett word Assembler namn $t0, $t1,, $t9 för temporära värden $s0, $s1,, $s7 för sparade (subrutin) värden Design regel: Mindre minne är snabbare

Register och primärminne Högnivåspråk: a=b+c; Assemblyspråk: ADD a, b, c Kompilatorn hittar en maskininstruktion som passar 3 minnesaccesser: Hämta b Hämta c Skriv a

Register och primärminne Högnivåspråk: a=b+c+d; Alternativ 1: ADD a, b, c //adderar b och c, resultat i a ADD a, a, d //adderar a (som är b+c) med d, resultat i a Antal minnesaccesser: 6=3+3 Tid för en minnesaccess: 100 ns gör att minnesläsning/ skrivning tar 600 ns

Register och primärminne Högnivåspråk: a=b+c+d; Alternativ 2: ADD r1, b, c //adderar b och c, resultat i register 1 ADD a, r1, d //adderar a (som är i r1) med d, resultat i a Antal minnesaccesser: 4=2+2 Tid för en: minnesaccess: 100 ns registeraccess 1 ns: Minnesläsning/skrivning tar 400 + 2 ns = 402 ns 30% sparad tid (600-402)/600

Primärminne LOAD läs i data i minne STORE skriv data i minne Adress Instruktion/Data 0 1111 0000 1 1010 0101 2 1100 0011 3 0011 0011 4 1111 1111 5 0000 1111 6 1111 0000 7 1010 1010

Variabler och minne Exempel, C deklaration x char; // värde mellan 0 och 255 1 byte 8 bitar ger att dessa tal kan representeras: Binärt Decimalt 0000 0000 0 0000 0001 1 0000 0010 2 0000 0011 3. 1111 1101 253 1111 1110 254 1111 1111 255

Variabler och minne Exempel, C deklaration x unsigned char; // värde mellan -127 och 127 1 byte 8 bitar: Hur representera - talen? Binärt Decimalt 0000 0000 0 0000 0001 1 0000 0010 2 0000 0011 3. 1111 1101? 1111 1110? 1111 1111?

Variabler och minne Alternativ 1: MSB är teckenbit //Most Significant Bit Får 2 nollor (-0 och 0) Binärt Decimalt 0000 0000 0 0000 0001 1 0000 0010 2. 1000 0000-0.. 1111 1110-126 1111 1111-127

Variabler och minne Alternativ 2: Två-kompliment Binärt Decimalt 0000 0000 0 0000 0001 1 0000 0010 2. 1000 0000-127.. 1111 1110-2 1111 1111-1 Exempel: -1 (1111 1111) + 1 = 0

Minne Exempel: C deklaration x char; // char behöver 1 byte LOAD r1, 3 // ladda register r1 med data som finns på plats 3 STORE r1, 3 / spara det som finns i register r1 på plats 3 Adress Instruktion/Data 0 1111 0000 1 1010 0101 2 1100 0011 3 0011 0011 4 1111 1111 5 0000 1111 6 1111 0000 7 1010 1010

Minne Exempel: C deklaration x int; // int beöver 2 bytes LOAD r1, 3 // ladda register r1 med data som finns på plats 3 och? STORE r1, 3 / spara det som finns i register r1 på plats 3 och? Adress Instruktion/Data 0 1111 0000 1 1010 0101 2 1100 0011 3 0011 0011 4 1111 1111 5 0000 1111 6 1111 0000 7 1010 1010

Byte eller wordadresserat minne Adress Byte Data 0 0 1111 0000 1 1 1010 0101 2 2 1100 0011 3 3 0011 0011 4 4 1111 1111 5 5 0000 1111 6 6 1111 0000 7 7 1010 1010 Adress Byte Data 0 0 1111 0000 1 1010 0101 2 1100 0011 3 0011 0011 1 4 1111 1111 5 0000 1111 6 1111 0000 7 1010 1010

Byte eller word adresserat minne? Byteadresserat Måste hålla koll på vad som ska anses vara ord Exempel: Läs adress 4, som är en del i ett ord. Wordadresserat: Läs word (4 byte) per gång. Fragmentering om en byte ska lagras (tar 4 bytes). Adress Byte Data 0 0 1111 0000 1 1 1010 0101 2 2 1100 0011 3 3 0011 0011 4 4 1111 1111 5 5 0000 1111 6 6 1111 0000 7 7 1010 1010

Hur sätts byte ihop till word? Byte 4, 5, 6, och 7 bildar ett ord, men hur ser ordet ut? Två alternativ: 1111 1111 0000 1111 1111 0000 1010 1010 (ordning 4, 5, 6, 7) Little Endian 1010 1010 1111 0000 0000 1111 1111 1111 (ordning 7, 6, 5, 4) Big Endian Adress Byte Data 0 0 1111 0000 1 1 1010 0101 2 2 1100 0011 3 3 0011 0011 4 4 1111 1111 5 5 0000 1111 6 6 1111 0000 7 7 1010 1010

ALU Primärminne Instruktioner och data Data/instruktioner Kontroll ALU Central processing unit (CPU) Register Fetch instruction Execute instruction

Processorn (CPU) Central processing unit (CPU) Digital signaling processor (DSP) Graphics Processing Unit (GPU) Flyttals Processor Unit (FPU)

Arithmetic Logic Unit (ALU) OP IN 1 UT ALU IN 2 Status

Kontrollenhet Primärminne Instruktioner och data Data/instruktioner Kontroll ALU Central processing unit (CPU) Register Kont roll Fetch instruction Execute instruction

Processorn

Kontrollenhet

Exekvering av en instruktion (1) Hämta instruktion på 00001000 (där PC pekar) Fetch (2) Flytta instruktionen 0000101110001011 till CPU (3) Avkoda instruktionen: 00001 MOVE, 01110001 Adress, 011 Register 3 (4) Hämta data på adress: 01110001 Execute (5) Lagra datan i register 3 Primärminne Address Instruktion/data 00001000 0000101110001011 00001001 0001101110000011 00001010 0010100000011011 00001011 0001001110010011 Data Instruktioner Register CPU Kontrollenhet Aritmetisk Logisk Enhet (ALU)

Sekventiell logik Register: lagrar data Använder klocka för att bestämma när data ska uppdateras Flank-triggat (Edge-triggered): uppdaterar när Clk går från 0 till 1 D Clk Q Clk D Q

Kontrollenhet ADD XOR ClearY System buss Z Z in ALU Y MBR MAR PC Z out Carry in Y out Y in MBR out MBR in MAR in PC out PC in R0 out R0 in RN out RN in IR in IR out Kontroll signaler MBR out R 0 R n IR Klocka Kontrollenhet Y in R0 RN out out MAR in Statussignaler Carry, overflow MAR out PC in ADD

Kontrollenhet Instruktion: ADD R1, R3 // R1 <- R1 + R3 Kontrollsteg: 1. PC out, MAR in, Read, Clear Y, Carry-in, Add, Z in 2. Z out, PC in 3. MBR out, IR in 4. R1 out, Y in 5. R3 out, Add, Z in 6. Z out, R1 in, End

Fetch Instruction 32-bit register Increment by 4 for next instruction

Kontrollenhet Kontroll signaler System buss MBR MAR ALU R 0 R n PC IR Klocka Kontrollenhet Statussignaler

Översikt Processorn Maskininstruktioner Adressering Hopp och subrutiner Inmatning/utmating (Input/Output (I/O)) Instruktionsformat

Maskininstruktioner Definitioner: Vad ska göras (operationskod)? Vem är inblandad (source operander)? Vart ska resultatet (destination operand)? Hur fortsätta efter instruktionen? 00001 101010111101110 011 Opcode Operand (minne) Operand (register)

Maskininstruktioner Att bestämma: Typ av operander och operationer Antal adresser och adresserings format Registeraccess Instruktionsformat» Fixed eller flexibelt

Maskininstruktioner Typer av instruktioner: Aritmetiska och logiska (ALU) Dataöverföring Hopp In- och utmatning

Aritmetiska operationer Addition (+) och subtraktion (-) Två källor (sources) och en destination (destination) add a, b, c # a får värdet b + c Alla aritmetiska funktioner följer detta mönster Design regel: Enkelhet föredrar regelbundenhet Regelbundenhet gör implementation enklare Enkelhet ökar möjligheten till högre prestanda till lägre kostnad

Aritmetiska operationer C kod: f = ( g + h ) ( i + j ); Kompileras till assemblykod (MIPS): add t0, g, h # temp t0 = g + h add t1, i, j # temp t1 = i + j sub f, t0, t1 # f = t0 - t1

Översikt Processorn Maskininstruktioner Adressering Instruktionsformat Hopp och subrutiner Inmatning/utmating (Input/Output (I/O))

Varför olika sätt att adressera? Öka flexibiliteten vid programmering, vilken förenklar programmering Antal bitar för att specificera en adress är begränsat. Exempel: Om 8-bitar används: Minne. Adress.. Extra tid (jmf ovan) kan 2 8 adresser pekas ut. Men, om 8-bitar används att peka ut ett register som innehåller adress kan 2 16 adresser pekas ut. Adress.. Minne R1 Adress. (16-bitar)

Adressering: avvägningar Få och enklar adresseringsmöjligheter Stora adressfält i instruktion för att kunna täcka stor adressrymd Begränsar programmering Snabbare adressberäkning Mindre komplex processor Många och avancerade adresseringsmöjligheter Tillåter mindre addressfält utan att påverka adressrymd Flexibel programmering Kan ge långsam adressberäkning Ökar komplexitet av processorn

Adressering Immediate adressering ADD R4,#3 //R4<-R4+3 Operanden finns direkt i instruktionen ADD R4 3

Adressering Direkt adressering ADD R4, 3 //R4<-R4+[3] Adressen till operanden ligger i instruktionen ADD R4 3 Adress 0 1 2 3 4 Data 11 22 33 44 55

Adressering Register adressering ADD R4,R3 //R4<-R4+R3 Liknar direkt adressering men istället för att peka ut i minnet så pekas ett register ut ADD R4 3 Register 0 1 2 3 4 Data 11 22 33 44 55

Adressering Register adressering ADD R4,R3 //R4<-R4+R3 Liknar direkt adressering men adressfält pekar ut register och inte minnet ADD R4 3 Register 0 1 2 3 4 Data 11 22 33 44 55

Adressering Memory indirect ADD R4,(3) R4<-R4+[[3]] Instruktionen innehåller adressen till en minnesplats som innehåller den önskade adressen ADD R4 3 Adress Med indirekt adressering kan en större minnesarea adresseras då stora adresser kan läggas i minnet och instruktionen pekar ut dem. Data

Adressering Register indirect ADD R4,(R3) R4<-R4+[R3] Liknar indirekt adressering men instruktion pekar ut register istället för minnesplats ADD R4 3 R3 Adress Data

Adressering Displacement ADD R4,R1.X R4 R4+[R1+X] Ett bas register (vanligen ett general purpose register) ger basen och ett par bitar ger displacement (en offset från base register) ADD R1 3 R1 + Adress Data

Adressering Indexerad ADD R4,X[R1] R4 R4+[X+R1] Liknar displacement men är tvärtom. Register (här R1) innehåller displacement (offset) från base givet i instruktionen ADD R1 3 R1 + Adress Data Indexerad adressering kan kombineras med auto increment/decrement förenklar arbete med arrayer

Adressering Relativ adressering Använd t ex PC för att skapa adress. Enbart liten bit finns i instruktionen ADD R4 3 PC + Adress Data

Hoppinstruktion Nästa instruktion antas normalt sätt vara nästa i programmet. PC=PC+1; Programräknaren (program counter) räknas upp och nästa instruktion hämtas För att göra hopp till annan del av kod, ladda programräknaren med nytt värde PC=ditt hopp ska sek Två typer av hopp Ovillkorliga hopp Villkorliga hopp

Ovillkorliga hopp Exempel: Programräknaren får nytt värde och hämtar nästa instruktion på nytt ställe Adress Instruktion Kommentar 01011 Instruktion 29 //Instruktion 29, PC=PC+1 01100 BR 10101 // PC = 10101, PC=PC+1 01101 Instruktion 31 //Instruktion 31, PC=PC+1 10101: Instruktion 89 //Instruktion 89, PC=PC+1

Villkorliga hopp Villkor bestäms av flaggor i statusregister De vanligaste flaggorna är: N: 1 om resultatet är negativt (annars 0) Z: 1 om resultatet är noll (annars 0) V: 1 om aritmetiskt overflow (annars 0) C: 1 om carry (annars 0) UT OP ALU IN 1 IN 2 Status

Villkorliga hopp Exempel: SUB R1, #1 BEZ TARGET Kan påverka statusflagga R1=R1-1 IF Z=1 THEN PC=TARGET Kollar statusflagga OP IN 1 N Z V C UT ALU IN 2 Status

Villkorliga hopp ADD XOR ClearY System buss Z Z in ALU Y MBR MAR PC Z out Zero Carry in Y out Y in MBR out MBR in MAR in PC out PC in R0 out R0 in RN out RN in IR in IR out Kontroll signaler MBR out R 0 R n IR Klocka Kontrollenhet Y in R0 RN out out MAR in Statussignaler Carry, overflow MAR out PC in ADD

Subrutiner och funktioner Program: void main(void){ int a, b, c; a=5; b=6; c=my_add(a,b); } Exekvering: a=5 //instruktion 1 b=6 //instruktion 2 funktionsanrop +parameteröverföring c=my_add(a,b); instruktion 11 återhopp+parameteröverföring int my_add(int x, int y){ return x+y; }

Subrutiner och funktioner Problem instruktion 1 call proc A instruktion 3 instruktion 4 call proc A instruktion 6 Hopp till subrutin Återhopp Parameteröverföring Nästlade subrutinanrop 5 1 8 4 proca: instruktion 11 call proc B instruktion 13 return 2 3 6 7 1 2 3 4 5 6 7 8 procb: Instruktion 21 Instruktion 22 return Exekvering: instruktion 1 instruktion 11 //Proc A Instruktion 21 //Proc B Instruktion 22 instruktion 13 //Proc A instruktion 3 instruktion 4 instruktion 11 //Proc A Instruktion 21 //Proc B Instruktion 22 instruktion 13 //Proc A instruktion 6

Subrutiner och funktioner instruktion 1 call proc A instruktion 3 instruktion 4 call proc A instruktion 6 Vid call: Innan hopp, spara PC proca: instruktion 11 call proc B instruktion 13 return Vid call: Innan hopp, spara PC procb: Instruktion 21 Instruktion 22 return Vid call: Innan hopp, spara PC Vid return: Kolla återhopp Vid return: Kolla återhopp

Återhopp och parameteröverföring Register Använd ett antal register för att spara återhoppsadress och för parameteröverföring Fördel: snabbt. Nackdel: register behövs Stack Reservera en del av minnet och skapa en kö som fungerar enligt Last-In First-Out Fördel: stort. Nackdel: långsamt (jmf register)

Stack 1 2 Två operationer: push och pop Push A A Adress Byte Data Push 0 A 0 1111 0000 1 1 1010 0101 3 Push B B A 4 Pop A 5 Pop 1 Stackpekare Stack 2 2 1100 0011 3 3 0011 0011 4 4 1111 1111 5 5 0000 1111 6 6 1111 0000 7 7 1010 1010

Stack 1 2 Två operationer: push och pop Push A A Adress Byte Data Push 0 A 0 1111 0000 1 1 1010 0101 3 Push B B A 4 Pop A 5 Pop 2 Stackpekare 2 2 1100 0011 3 3 0011 0011 4 4 A 5 5 0000 1111 6 6 1111 0000 7 7 1010 1010

Stack 1 2 Två operationer: push och pop Push A A Adress Byte Data Push 0 A 0 1111 0000 1 1 1010 0101 3 Push B B A 4 Pop A 5 Pop 3 Stackpekare 2 2 1100 0011 3 3 0011 0011 4 4 A 5 5 B 6 6 1111 0000 7 7 1010 1010

Stack för subrutiner och funktioner Push 10 (tid 2) Push 2 (tid 1) Push 10 (tid 6) 10 2 5 10 2 instruktion 1 call proc A instruktion 3 instruktion 4 call proc A instruktion 6 Push 5 (tid 5) proca: instruktion 11 call proc B instruktion 13 return Pop (tid 4) ger 2 10 2 procb: Instruktion 21 Instruktion 22 return Pop (tid 3) ger 10 10 2 5 Pop (tid 8) Pop (tid 7) Ger 5 10 ger 10 5 10 5

Register för subrutiner och funktioner R 0 Alla register R N Level i Register window In Local Out CWP: Current Window Pointer Level i+1 Level i+2 CWP CWP In Local Out In Local Out instruktion 1 call proc A instruktion 3 instruktion 4 call proc A instruktion 6 proca: instruktion 11 call proc B instruktion 13 return procb: Instruktion 21 Instruktion 22 return CWP

In- och utmatning Läsning och skrivning: Enhet för indata Primärminne (CPU) Enhet för utdata Sekundärminne

Minnesmappad och isolerad I/O

Exempel på minnesmappad I/O LOAD R1, 7 //Ladda R1 med värde på adress 7 STORE R1, 6 //Lagra värdet i R1 på adressplats 6 Adress Instruktion/ Data 0 1111 0000 1 1010 0101 2 1100 0011 3 0011 0011 4 1111 1111 5 0000 1111 6 0010 0000 7 0010 0000

Instruktionsformat Hur definiera fälten i instruktioner? Opcode Operand1 Operand2 Hur ska högnivåspråk kompileras och exekveras effektivt? Abstraktionsnivå Högnivåspråk Maskinspråk Semantiskt gap

Semantiskt glapp Två alternativ: CISC (Complex Instruction Set Computers): utveckla komplex arkitektur med många instruktioner och många adresseringsmöjligheter; ta med instruktioner som liknas högnivåinstruktioner. RISC (Reduced Instruction Set Computers): förenkla instruktionsuppsättningen och anpassa den till de verkliga kraven ett applikationsprogram har

Instruktionsformat Vissa opcoder har givet adressläge (ex. I/O) medan andra kan tillåta olika moder. Opcode Operand1 Operand2 Mode bits ADD R4,#3 //R4<-R4+3 ADD R4, 3 //R4<-R4+[3] ADD R4,R3 //R4<-R4+R3 För adressering: peka ut alla register och nå all data i minnet.

Antal adresser i instruktion För att beräkna: X = (A+B)*C 4-adress instruktioner: Op A1, A2, A3, A4 //A1 <- [A2] op [A3], nästa instruktion = A4 I1: ADD X, A, B, I2 I2: MUL X, X, C, I3 I3: 3-adress instruktioner: Op A1, A2, A3 //A1 <- [A2] op [A3] I1: ADD X, A, B I2: MUL X, X, C I3: OP A1 A2 A3 A4 OP A1 A2 A3

Antal adresser i instruktion För att beräkna: X = (A+B)*C 2-adress instruktioner: Op A1, A2 //A1 <- [A1] op [A2] MOVE A, X ADD X, B MUL X, C 1-adress instruktioner: Op A1 //Acc <- [Acc] op [A1] LOAD A ADD B MUL C STORE X OP A1 A2 OP A1

Antal adresser i instruktion Vanligast med 2 och 3 adresser i instruktioner 4 adress instruktioner är opraktiskt. Nästa instruktion antas vara nästa instruktion. PC räknas upp av sig själv. Måste ha hopp-instruktioner 1 adress instruktion är ganska begränsande Exempel, antag 32 register (5 bitar behövs): 3-adress format: 15 bitar 2-adress format: 10 bitar 1-adress format: 5 bitar OP Rdest Rsrc1 Rsrc2 Få adresser, få instruktioner förenklar processorn men gör den mer primitiv

Intel x86 ISA Utveckling med backward compatibility 8080 (1974): 8-bit microprocessor» Accumulator, plus 3 index-register pairs 8086 (1978): 16-bit extension to 8080» Complex instruction set (CISC) 8087 (1980): floating-point coprocessor» Adds FP instructions and register stack 80286 (1982): 24-bit addresses, MMU» Segmented memory mapping and protection 80386 (1985): 32-bit extension (now IA-32)» Additional addressing modes and operations» Paged memory mapping as well as segments

Intel x86 ISA Bakåtkompabilitet (Backward compatibility)

Sammanfattning Processorn består av register, aritmetisk enhet (ALU) och en kontrollenhet Registren används för att lagra data/instruktioner temporärt ALU:n gör alla beräkningar Kontrollenheten styr aktiviteten i processorn

Sammanfattning Instruktionsuppsättningen och dess format är karakteristiskt för en processor Normalt sett har en processor instruktioner för förflyttning av data, aritmetiska/logiska beräkningar, programkontroll (hopp), och I/O. För programkontroll (hopp) finns ovillkorliga och villkorliga hopp. Villkorliga hopp tas beroende på innehåll i statusregister Subrutiner, procedurer och funktionsanrop kan lösas med hjälp av en stack eller register I/O funktioner kan vara minnesmappade I/O hanteras med läsning och skrivning i minnet eller som isolerad I/O speciella instruktioner för I/O

Sammanfattning Adresser till operander kan specificeras om olika sätt. Adressering ska göras till stor adressrymd, flexibelt för programmeraren, och med snabb adress översättning Addressing modes: Immediate addressing Direct + Register addressing Indirect addressing Displacement, Relativ och Indexed Stack adressing Instruktionsformat definierar hur bitarna/fälten i en instruktion är organiserade och hur långa de är. Instruktioner kan vara av fixed längd eller flexibel längd