2G1510 Datorteknik fk Föreläsning 1, hösten 2003

Kursens upplägg ● Föreläsningar (9 stycken) ● Övningar (6 stycken) ● Laboration (1 labb i labbsal) ● Litteraturuppgift (1 forskningsartikel) ● Tentamen (4 timmar)

Laboration ● Implementationsteknik: mikroprogrammering ● Skriv mikroprogram för en enkel CPU ● Skriv enkla assemblerprogram och översätt till binär maskinkod ● Koppla ihop CPUns delar med sladdar ● Knappa in mikroprogram ● Knappa in binärt maskinkodsprogram och provkör

Litteraturuppgift ● Kursmål: läsa och förstå aktuell forskning ● Välj aktuell forksningsartikel (alla har olika) ● Läs, förstå, följ upp bakgrund med mera ● Gör en redig och intressant presentation av allt väsentligt i artikeln på 15–20 minuter

F/Ö/T ● Föreläsningar – hjälp vid studiet av kursbok – läsanvisningar kommer ● Övning 1 och 2 – hjälp inför laborationen ● Övning 3–6 – hjälp med typiska tentatal ● Tentamen – 4 timmar, miniräknare

Administration ● Boka labbtid – på papper – i samband med föreläsningarna ● Boka presentationstid och artikel – bokas alltid samtidigt – på papper hos mig, eller – med till mig ● Anmälan till tentamen 20 december 2003 – senast 7 december 2003 – mer information senare

En vanlig femstegspipeline FDEMW FDEMW FDEMW FDEMW tid

En superskalär femstegspipeline av grad 2 tid FDEMW FDEMW FDEMW FDEMW FDEMW FDEMW FDEMW FDEMW

Beroenden ger stopp i röret tid FDEMW FDEMW FDEMW FDEMW FDEMW FDEMW FDEMW FDEMW stall Instruktion 1 beräknar ett värde......som instruktion 2 använder

Extra hårdvara ● Ökad bandbredd från instruktionscache ● Dubbla instruktionsavkodare ● Fler läsportar på registerfilen ● Bypassing ökar kvadratiskt (4n 2 ) ● Flera funktionsenheter - dubbel ALU ● Flera portar till datacacheminnet

Heltal parallellt med flyttal ● Instruktionsuppsättningen har ofta separata register för heltal och flyttal ● Funktionsenheterna är alltid separata ● Sällsynt med beroenden mellan heltals- och flyttalsinstruktioner ● Separata bypassvägar

Mer att göra för avkodaren ● Ska upptäcka beroenden ● Ska skicka instruktioner till rätt enhet ● Mer att göra tar längre tid - superskalära datorer har ofta 2-3 avkodningssteg ● PPro/II/iii har 3-7 steg, beror på hur man räknar

Ny pipeline ● Två avkodningssteg, Decode och Register read ● Hoppinstruktioner:  Efter D-steget vet vi vart vi ska hoppa  Efter R-steget vet vi om vi ska hoppa FDREMW

Hopp blir dyrt tid FDREM FD--- F---- FDREM FDR-- FD--- F---- FDREM W - - W W

Branch penalties ● Misfetch penalty (1 cykel, D-steget) – förlorad tid när man hämtat ett hopp och gissar rätt att man ska hoppa ● Mispredict penalty (2 cykler, D + R) – förlorad tid vid felgissning – först i R-steget vet man att gissningen var fel FDREMW Samtidigt hämtas alltid nästa instruktion i ordningsföljd

Superpipelining ● startar en instruktion per klockcykel ● har extra kort cykeltid – E1 och E2 behövs för ALU, en beroende instruktion kan inte starta i cykeln efter F1F2D1D2E1E2M1M2W1W2 FDEMW vanlig femstegspipeline superpipelinad av grad 2

Exempel ● Pentium Pro/II/iii, Pentium 4 är superpipelinade ● Exec tar 1 steg, decode tar många - ojämnt! Pentium: 5 steg PPro/II/iii: 10 steg P4: 20 steg

Latens (latency) ● Latens - cykler tills resultat kan användas ● ALU-instruktioner har ofta latens 1 – beroende instruktion kan köras i nästa cykel - men inte i samma! ● LOAD i femstegpipeline har latens 2 ● Hopp har ofta lång latens – särskilt när hoppgissningen misslyckas

Genomsnittlig grad av superpipelining ● Anta: – Om Load och hopp har latens 3, ALU 1 – Load och hopp är vardera 25% av de utförda instruktionerna ● Genomsnittlig grad av superpipelining: – 0,25 x 3 + 0,25 x 3 + 0,50 x 1 = 2,0

Tolkning ● Värdet 2 betyder att: – det program som körs bör vara sådant att det för det mesta finns 2 saker att göra samtidigt – i genomsnitt ska varje instruktion följas av en oberoende instruktion ● Det finns gränser för hur mycket som finns att göra samtidigt i typiska program – värden på 2-4 är rimliga, knappast mer

Nivåer i datorsystem ● kompilering – avancerad översättning ● assemblering – rak översättning ● interpretering – hämtfas, utförandefas fast med program ● exekvering – samma som körning C-kod assemblerkod maskinkod mikroprogram hårdvara kompilering assemblering interpretering exekvering

Antalet operander/instruktion ● 0 - stackmaskin – ADD - adderar värdena överst på stacken, tar bort dem och lägger dit summan ● 1 - ackumulatormaskin – ADD X - adderar innehåll i ackumulatorn och innehåll i minnescell X, summan i ackumulatorn ● 2 - tvåadressmaskin - ADD R1,R2 ● 3 - treadressmaskin - ADD R1 <- R2 + R3

Antalet minnesadresser/instruktion ● 0 – registermaskin (som MIPS, Nios, Sparc) särskilda Load- och Store-instruktioner finns ● 1 – register-minne (x86) ● 2 – minne-minne (ovanligt numera) ● 3 – minne-minne (också ovanligt)

Exempel: stackmaskin ● Kod för C = A + B – push A; innehåll i minnescell ; med adress A läggs på stacken – push B – add – pop C; översta värdet på stacken tas ; bort och skrivs till minnescell ; med adress C

Exempel: ackumulatormaskin ● 1 operand/instruktion, 1 minnesadress/instruktion ● Kod för C = A + B – Load A; innehåll i minnescell med ; adress A kopieras till ackumulator – Add B – Store C; innehåll i ackumulator kopieras ; till minnescell med adress C

Exempel: registermaskin av register-register-typ ● 3 operand/instruktion, 0 minnesadresser/instruktion ● Kod för C = A + B – Load R1,A – Load R2,B – Add R3 <- R1 + R2 – Store R3,C

De första datorerna var ackumulatormaskiner ● Varje bit som skulle lagras i processorn krävde flera elektronrör ● Instruktioner kan kodas enkelt och ändå kompakt ● x86-arkitekturen är en utbyggd ackumulatormaskin

Stackmaskiner – eleganta men opraktiska ● Endast två värden är enkelt tillgängliga ● Ett värde som återanvänds i ett uttryck kan behöva läsas från minnet flera gånger ● Aritmetiska uttryck lätta att kompilera till program för stackmaskin ● aktuell stackmaskin: Java Virtual Machine

Register-register-maskin, Risc ● Risc: enkelt instruktionsformat, lätt att avkoda ● Många register – lätt att kompilera för ● Lätt att konstruera pipelinade processorer ● Programmen större än för andra typer – instruktionerna är inte kompakt kodade – programmen innehåller fler instruktioner än för datorer med operander i minnet

Operandutpekning ● Operand: värde som används i beräkningen ● Immediate: operanden finns i instruktionen ● Register: operanden finns i ett register ● Om operanden finns i minnet så existerar effektivadressen: adressen till den minnescell där operanden finns

Varför immediate behövs ● För konstanter ● Konstanterna finns i koden, bra eftersom – värdet är snabbt tillgängligt – värdet tar inte upp plats i ett register – koden ändras inte under körning, "konstanter" som ändras kan ge svårfunna fel

Goda tumregler för processorkonstruktörer ● Ortogonalitet: operationer, datatyper, adresseringssätt ska kunna väljas oberoende av varandra – underlättar kodgenereringen ● Erbjud byggblock, inte specialinstruktioner ● Gör det lätt att se hur snabb koden blir

Multimediainstruktioner ● Grafik använder små heltal (8 bitar) ● 8 små heltal ryms i ett 64-bits register ● Operationer utförs på 8 tal samtidigt ● Bryt carry-kedjan, använd vanliga ALU:n ● Idéer lånade från vektordatorer, men de var mer flexibla

Multimediainstruktionernas brister ● Vektorelement som ska laddas till register är ofta utspridda i stället för intilliggande ● Vektordatorer: load/store för utspridda data – strided addressing: t ex vart 3:e element – gather/scatter: en vektor med pekare anger vilka vektorelement som ska laddas/lagras ● Multimediatillägg saknar denna adressering

En dålig idé: delayed branch ● Definition: instruktionen efter ett villkorligt hopp utförs alltid, även om hoppet tas ● Idealiskt i femstegspipeline ● Problematiskt i alla andra pipelines

En dålig idé: registerfönster ● En Sparc-processor har register, men bara 32 i taget är tillgängliga ● R0-R7 är globala (och R0 innehåller alltid 0) ● R8-R31 ingår i registerfönstret ● Fönstret ändras i steg om 16 med instruktionerna save/restore

save (funktionsanrop) restore (retur från funktion)

Varför registerfönster är en dålig idé ● Registerfönster optimerar anrop till och retur från funktioner/procedurer/metoder ● Vid processbyte har man register som ska sparas (R0 är borträknat) ● Processbyte inträffar oftare än funktionsanrop

Dåliga idéer kan vara bra ● Ett par dåliga idéer räcker inte för att slå ihjäl en instruktionsuppsättning ● Delayed branching bidrog till att höja prestanda när Risc var nytt och okänt ● Registerfönster skapade intresse för Sparc ● Med tiden får man tillräckligt med kisel för bra prestanda trots gamla dåliga idéer