Praktiska kommentarer TSEA8 Datorteknik Y (och U) Föreläsning Kent Palmkvist, ISY Dagens föreläsning Latens/genomströmning Pipelining Laboration tips Sorteringsalgoritm använder A > B i flödesschemat Exemplet på instruktion är BGE motsvarande A ³ B Sorteringstävlingen deadline: Torsdag / kl :9. Jag ska kunna ladda design, ändra värden i PM adress E0-FF, trycka på regs=0, nollställ klockcykler, och sedan Kont. Sista maskinkodsinstruktionen ska vara HALT från :a delen av labben (eller använda SEQ-fältet). Praktiska kommentarer, forts. Vad säger flaggor vid subtraktion A-B? Subtraktion implementeras som A+(-B), dvs vänd tecken på B och lägg ihop. -B fås genom att vända alla bitar i B och lägga till i LSB (minnessiffra till höger) Z: om subtraktionen gav noll som svar, dvs A=B Konflikter C: om subtraktionen gav carry ut, gäller positiva heltal Stall/bubblor : differensen är negativ (om differensen kan representeras) O: spill (overflow) när svaret beräknades (för -komplementstal) Exempel (antag -bitars tal => talområde -8 till +), A-B = A+(-B) Datakonflikt Branch prediction -= -=- --=-0 -(-)=0-8-=- -(-8)= 00 +0 ----000 000 +00 ----0 C= =0 O=0 C=0 = O=0 00 +00 ----00 000 +00 ----00 000 +000 ----000 0 +0 ---- C= =0 O= C=0 = O= C= =0 O= C=0 = O= OBS: -bitar = 0000 -= 0 = 0000 -= 00 = 000 -= 00 = 00 -= 00 8= 0000-8= 000 0= 000-0= 00 = 0 -= 000 otera O= respektive O<>
Enkel RISC-baserad struktur RISC-arkitektur av LOAD-STORE typ Endast läsning/skrivning med instruktion (LOAD respektive STORE) Övriga instruktion sker endast med register i registerfil Klockfrekvens begränsas av längsta väg från register till nästa register Instruktion LDR D,(S,#L) ; opcode dest,src ; Minne(S+L) -> register D L kommer från maskinkoden, teckenförlängs och adderas Enkel RISC-baserad struktur, forts. Exekveringstid i exemplet Enkelt exempel från kursboken (avsnitt.) Ingen mikrokod Maskininstruktionens bitar styr enheterna direkt (Write_Destination, ALU Function etc.) utgående från opcode och registerfält -bitar instruktion ( byte) => öka PC med vid varje instruktion 8 Exekveringstid i exemplet Klockfrekvens begränsas av längsta väg från register till nästa register Instruktion LDR D,(S,#L) ; Läs minnescell som (S) +L pekar på tcycle = tpc + timem + trf + talu + tdmem + tmplx + trf
9 Hur pipelining adderas till strukturen IR mellan instruktionsminne och registerfil Register mellan registerfil och ALU Pipeline snitt (dvs register) Sdata fördröjs klockcykler innan minnet Måste få data i rätt klockcykel jämfört med minnesadress Styrsignaler fördröjs (måste hänga ihop med instruktionerna) 0 Resultat från krets/minne passerar nästa register efter stigande flank hos klockan Hela klockcykeln tillgänglig för beräkning/access Fördröjer resultat klockcykel per steg Indikera vilken instruktion aktiv vid varje tidpunkt i respektive register Pipeline snitt Pipelining: Dela upp i fler steg (t ex ) Timing hos pipeline Flera klockcyklers fördröjning Lägg in register i dataflödet Flera instruktionen hanteras parallellt Hämta instruktion, Läs operand,beräkna (ALU-operation), Minnesaccess, Skriv till registerfil Implementeras med klockade register mellan de olika enheterna Figuren lite missvisande: från vänster tidigare instruktioner, från höger senare instruktioner
Begrepp: latens, genomströmning Latens: Hur lång tid det tar att få utföra en komplett instruktion Genomströmning: Hur många instruktioner per sekund som kan utföras /Genomströmning = hur ofta en ny instruktion startas För pipelining: Latens > /Genomströmning Ökar maximalt antal operationer per sekund Minskar ITE tid för en enskild operation att slutföras Databeroende mellan operationer begränsar hur användbar ökning av klockfrekvens är latens Villkorliga hopp behöver flaggorna satta innan hopp kan göras /genomströmning Behöver OP (o-operations) läggas till mellan compare och villkorligt hopp? Pipelining: Fler steg Om alla steg tar lika lång tid Operand read kan vara väldigt enkel => behöver inte så lång tid Minnesläsning/skrivning kan ta lång tid Ignorerar just nu eventuella databeroden etc. ARM (00) Tillåter flaggorna att beräknas innan villkorliga hoppet avgör om hopp ska tas Exempel på olika pipelinedjup Borde ge upp till gånger högre klockfrekvens Pipelining tillåter högre klockfrekvens Pipelining är inte perfekt lösning Intel Pentium (00) Hämtar instruktioner innan föregående instruktioner slutförts Läser register innan föregående instruktion skrivit register stegs pipeline i Haswell pipeline (0) stegs pipeline AMD (00) 8 steg till 9 steg
Placera in register (flipflops) Måste ge registerfil tid att spara värde från minne Olika delar i instruktion behövs vid olika tidpunkter Måste hålla destinationsadress en cykel längre ( cykel för skrivning) Lösning: Stall (stoppa aktivitet i alla andra pipelinesteg) 8 Timingexempel Store instruktion Läs instruktion, hämta operander, beräkna adress, skriv i minnet 9 Problem vid load (minnesläsning) Även IR är klockad 0 Konflikter (hazards) ästa Store instruktion kan starta direkt Flera instruktioner exekveras delvis samtidigt Resultat från en instruktion ofta indata till nästa Resultat från en instruktion är inte alltid tillgänglig till nästa instruktion Vid konflikter kan pipeline behöva stannas Jfr den inte hämtade instruktionen vid LOAD Kallas pipeline stall eller bubblor
Typer av datakonflikt (data hazard) Läs efter skriv Föregående instruktion har inte sparat resultat som ska användas i nuvarande instruktion Skriv efter läsning Vanligen inget problem (kommer i senare föreläsning) Lös problemet genom att kräva minst en instruktioner mellan varje databeroende Skriv efter skrivning Vanligen inget problem (kommer i senare föreläsning) R0 uppdateras i samma klockcykel som andra instruktionen vill läsa R0 Ex: Add r0,r,r Add r,r,r0 Bättre om annan instruktion utan kan placeras in istället (inte alltid möjligt) Op: ADD R0,R,R ; R0 = R+R Om pipelinedjup ändras måste programmet skriva om Kompilerad kod inte portabel! ADD R,R0,# ; R = R0+ ADD R,R0,# ; R = R0+ Op: ADD R0,R,R ; R0 = R+R OP ADD R,R0,# ; R = R0+ ADD R,R0,# ; R = R0+ Enkelt: STALL (ger bubblor i pipeline) Tvinga nästa instruktion vänta på data (sänker fortfarande prestanda vid konflikt) Programmeraren behöver inte hålla reda på databeroende Exempel Kräver stall? Läs R0 (i+) Går inte läsa och skriva i RF på samma adress samtidigt ; i (r0=r+r) ; i+ (r=r0+r) Registerbanker klarar inte skriva och läsa samma adress i en klockcykel Programmeraren/kompilatorn måste hålla reda på databeroende och lägga till OP (no operation) => sänkt prestanda Hantering av RAW (bättre?) R0 uppdateras i instruktion i, läses i instruktion i+ Data hazard exempel (RAW) Det är inte en bugg, det är en feature... WAW (Write After Write) WAR (Write After Read) Hantering av RAW (mindre lämplig) RAW (Read After Write) Spara R0 (i) stall mellan instruktion och => två ej utnyttjade möjligheter att utföra instruktioner motsvarande OP inlaggda mellan instruktion och ADD Rx,Ry,Rz ; Rx = Ry+Rz Klockcykel 8 9 ADD R0,R,R ADD R,R,R ADD R,R,R S S ADD R,R,R = Instruction Fetch = Operand Fetch = Operation Execution = Operand Store S = Stall
Hantering av RAW (bäst) ästa instruktion hämtas innan hopp avkodats Skicka data direkt från resultat till operand (ej via ALU resultatregister) Execute påverkar programräknare (PC) Jämför destination för resultat hos nuvarande instruktion med källregister för nästa instruktion (styr mplx före s och s latch) Måste låta bli utföra två instruktioner Kräver mer logik (jämförare mellan destination och source samt multiplexer) Gäller även subrutinanrop, avbrott etc. Villkorliga hopp som inte tas kostar inget extra ADD R0,R,R ADD R,R,R ADD R,R,R ADD R,R,R Kasta bort hämtade instruktioner Förlorar ingen klockcykel = Instruction Fetch = Operand Fetch = Operation Execution = Operand Store Forward, timing Styrkonflikt Forward Klockcykel 8 Styrkonflikt (mindre lämplig lösning) Exempel ADD R,R,R ; Destination R ADD R,R,R ; Källa R Det är ingen bugg, det är en feature... Räkna med att alla hopp även utför en eller möjligen två instruktioner efter hoppinstruktionen Känt som Delayed branch Kan behöva lägga till OP (=> sänkt prestanda) mov r,# bra next mov r,# ; utförs också : next: add r,r,r
9 Kräv inte att programmeraren tar hänsyn till problemet Undvik krav på kännedom om hur processorn ser ut inuti Försök korrigera/hantera problemet internt i processorn Minska antal ej utnyttjade klockcykler Svårt då adress till nästa instruktion inte känd i förväg Axel är aktivitet eller instruktion Tidsaxel vågrätt eller lodrätt 0 0 Klockcykel i i+ i+ i+ i+ i- I i+ i+ i+ I- I- I I+ i+ I- I- I- i i+ ADD R0,R,R OP ADD R,R0,# ADD R,R0,# = Instruction Fetch = Operand Fetch = Operation Execution = Operand Store S = Stall Hopp, alternativ vy Instruktion i är BRA Hoppet avkodad i klockcykel (), instruktion hämtas i klockcykel Två bubblor, i+ och i+ Klockcykel ADD R0,R,R ; R0 = R+R OP ADD R,R0,# ; R = R0+ ADD R,R0,# ; R = R0+ = Instruction Fetch = Operand Fetch = Operation Execution = Operand Store S = Stall Hopp, kostnad i i+ i+ i+ Klockcykel Försök undvika kostnaden för hopp Samma händelser, olika sätt beskriva beroende på axlar Ändrad arkitektur kan ge andra krav... Alternativa sätt att beskriva händelser i CPU Styrkonflikt (bättre lösning) 0 Instruktion i- i- i i+ i+ + + + = Instruction Fetch = Operand Fetch = Operation Execution = Operand Store 8 9 0 Vid hopp uppstår bubblor i pipeline Antag instruktion i är BRA I utförandefasen är den nya adressen beräknad I exemplet uppstår två tomma klockcykler (i+ och i+) Hämtade men ej utförda instruktioner Cykel 0 8 9 Fetch instr. i- i- i (BRA) i+ i+ + + + + Hämta operand i- i- i- i (BRA) i+ + + + Utför i- i- i- i- i (BRA) + + Spara resultat i- i- i- i- i- i (BRA) +
Förbättra hantering av hopp Endast en klockcykel förloras Vanliga instruktioner tar klockcykel Ett hopp har ofta inga operander som behöver hämtas Sannolikhet för en hoppinstruktion är pb Sannolikhet för att hopp tas är pt Hopp som tas kostar b klockcykler extra Hopp som inte tas kostar inget extra (tar klockcykel) 8 BRA label ; offset lagrad i IR som literal i instruktionen Fetch Instr. i (BRA) i+ (bubbla) + + + + Hämta operand i- i (BRA beräknad) i+ (bubbla) + + + Utför Spara resultat i- i- i- i- I i- i+ (bubbla) i i+ (bubbla) + + + Olika typer Ovillkorliga hopp Hopp utförs alltid Villkorliga hopp tillbaks i loopar Andra villkorliga hopp Medelvärde på antal klockcykler per instruktion T ave =( p b) + p b pt (+b)+ p b ( p t ) =+ pb pt b Typer av hopp Antaganden Cykel Kostnad för hopp Detektera hopp redan vid operandhämtning Hopp tas ofta Effektivitet beroende på antal tagna hopp pe = pbpt, dvs hur sannolikt är det att instruktionen är ett villkorligt hopp som tas Djup pipeline blir dyr när hopp tas Hopp som tas kostar b klockcykler extra Lika sannolikt hopp inte tas som att det tas Viktigt försöka minska påverkan av villkorliga hopp som tas
Försök att minska antal hopp ARM har t ex ADDEQ R,R,R Möjliggör sekvensiell kod med villkor utan hopp HP-PA (och AVR) har skip-next instruktion (villkorliga) Statisk hopp-prediktering missar många hopp Utför instruktionen endast om Z-flagga = 0 Fler än % av alla hopp missas Bättre lösning: Dynamisk hoppprediktering Kom ihåg om hoppet togs förra gången koden kördes Sparas internt i processorn för varje villkorlig hoppinstruktion som påträffas Utför inte nästa instruktion om villkor sant Kan skapa if then else kod utan hopp Försök förutsäga hopp Om instruktionshämtaren i förväg vet att hopp kommer göras kan den hämta instruktioner från andra adresser Fördröjning kan då undvikas då rätt instruktioner kan hämtas och börja avkodas Omöjligt att förutsäga villkorliga hopp 8 Om rätt gissning görs förhindras förlorade klockcykler Kan i vissa processorer ange i instruktionen om hoppet oftast förväntas tas eller inte Statisk hopp prediktering Bestäms vid kompilering av koden Begränsat antal adresser kan kommas ihåg Ännu bätte förutsägelse om inte bara det senaste hoppet används som förutsägelse Majoritet av visst antal av senaste exekveringar kan ange mest sannolika förutsägelse Hysteres kan användas 0 Hopp prediktering, implementering Olika hopp har olika gissning Spara gissning för varje enskilt villkorligt hopp Dyrt minne (associativt minne) Kan gissa om nästa instruktion utan att nuvarande instruktion lästs Kan gissa, mer eller mindre rätt 9 Att förutsäga hopp Skapa instruktioner som tillåter villkorliga operationer Måste kört koden innan tabellen fyllts
Hur branch prediction fungerar Resultat från flera villkorliga hopp kan vara korrelerade Tappar klockcykler i exemplet Vissa mönster kan finnas som kan säga mer om vilka hopp som sannolikt kommer hända Branch pattern history Förbättrad Branch Target Buffer Två nivåers branch prediction Problem med miss består i att instruktionen inte kan börja avkodas Lagra opcode från adress som inte förväntas läsas Två nivåers branch predictions Fortfarande dyrt att gissa fel Använd mönstret av senaste villkorliga hopp för att välja en prediktor som användes senast detta mönstret sågs Om fel förutsägelse så finns opcode redan tillgänglig Har troligen gått genom samma sekvens av villkorliga hopp, och kommer då troligen göra samma val framöver
www.liu.se