IS1200 Föreläsning 10

1. IS1200 Föreläsning 10 Mats Brorsson, matsbror@kth.se KTH /ICT Programvaru- och datorsystem SICS – Swedish Institute of Computer Science

2. Innehåll • Vad drar energi? • Ett par arkitekturknep att minska energiförbrukningen i processorer • Multicore: en lågenergiteknik? • Vad behövs för att bygga en multicore?

3. MEM/WB ID/EX EX/MEM IF/ID Adder 4 Address ALU En enkel pipeline (MIPS) Instruction Fetch Execute Addr. Calc Memory Access Instr. Decode Reg. Fetch Write Back Next PC MUX Next SEQ PC Next SEQ PC Zero? RS1 Reg File MUX Memory RS2 Data Memory MUX MUX Sign Extend WB Data Imm RD RD RD A <= Reg[IRrs]; B <= Reg[IRrt] IR <= mem[PC]; PC <= PC + 4 WB <= rslt Reg[IRrd] <= WB rslt <= A opIRop B

4. Och cacheminnen... Datapath L1 I L1 D L2/3 I+D

5. Vad tar energi? • Mikroprocessorer är byggda av CMOS transistorer • Kretsen visar en inverterare • In = 0 => Out = 1 • In = 1 => Out = 0 Vdd = 1 In Out = 0

6. En enkel introduktion till inverteraren • CMOS-transistorer kan ses som strömbrytare • P-transistorn öppnar när in=1 • N-transistorn öppnar när in=0 • Efterföljande kretsar kopplade på utgängen ger en kapacitiv last, C • Kapacitansen, C, kan hålla en elektrisk laddning, Q • En laddning i C betyder en hög spänning på utången (1) • Ingen laddning, låg spänning (0) Vdd = 1 N In Out P C = 0

7. CMOS Invertereraren • Antag ingången är 1 • P-transistorn är öppen vilket betyder att det finns en ledning till jord => utgången=0 Vdd = 1 N Closed Out = 0 In=1 Out = 0 P Open = 0

8. CMOS-invertereraren i aktion • In går från 1 till 0 • Då öppnar N-transistorn • Och P-transistorn stänger • Kapacitansen laddas då från Vdd • Utgången ändras från 0 till 1 • När In går från 0 till 1, laddas kapacitansen ut genom P-transistorn • Varje upp- och urladdning bränner effekt! Vdd = 1 N Opens In → 0 Out → 1 P Closes = 0

9. Statisk effektförbränning • Även i stabilt tillstånd går det vissa läckströmmar genom transistorerna • De är alltså inte perfekta strömbrytare Vdd = 1 In Out = 0

10. CMOS Effektförbränning (almost) •  är en aktivitetsfaktor • C är den samlade kapacitansen • Vdd är matsningsspänningen • f är klockfrekvensen • Ileak är de samlade läckströmmarna • Eftersom f  Vdd (inom vissa gränser)  P  Vdd3

11. Några tekniker att minska energiåtgång • Tekniker för cacheminnen • Små, korta instruktioner

12. 4-way set associative cache memory

13. Teknikerförattminskaenerginicacheminnen • Mängd-associativacacheminnenhar bra prestanda, men de drarmycketenergi • Access till datadelendrarmycketmerenergiän till adressetiketterna. (Varför?) • De flestaoptimeringargörsfördatadelen • Olikatekniker: • Fasad access • Sekventiell access • Way prediction • Way selection

14. Phased access • Kolla först om data finns i cachen • Bara då läses data-delen • Energi sparas vid miss i cachemissen • Prestanda förloras vid träff i cachen • Kan minskas om man pipelinar cacheminnet Figures from Kaxrias & Martonosi, COMPUTER ARCHITECTURE TECHNIQUES FOR POWER-EFFICIENCY

15. Sequential access • Titta i en väg åt gången • Börja i den senast använda (MRU=Most Recently Used) • Energi sparas om man ofta hittar rätt tidigt • Prestanda förloras om man inte hittar rätt tidigt

16. Way prediction • En prediktor pekar ut den väg där data tros finnas • Energi sparas om man gissar rätt • Prestanda förloras om man gissar fel

17. Vart går energin i en processor? Små cacheminnen betyder mer energi i DRAM-access Stora cacheminnen betyder mer energi i cacheaccess. Kan man ha mindre cacheminnen med kapaciteten hos ett större genom att komprimera innehållet? Varierande storlek på instruktionscache

18. CGO Paper

19. Multicore processors Why and How

20. The Free Lunch 1995-2000 • SPEC INT CPU 95 • Exponential increase in speed • CPU INT does not really track execution time well....

21. The Free Lunch 1999-2006? • SPEC INT CPU 2000 • Not so exponential increase in speed

22. 2012 state-of-the-art, high-end

23. 2012 state-of-the-art, embedded

24. We’re going manycore

25. Why Multicore?or, where is my free lunch? • Software developers were used to ever increasing performance, for free • Increasing clock frequencies • Increasingly advanced architectures exploiting Instruction level parallelism (ILP) • Larger cache memories • However, • Clock frequencies no longer go up! • We have exhausted the available ILP in applications • Parallelism is the only way increasing performance significantly

26. Software development == Development for Multicore

27. Moore’s law • Moore’s law: 2X transistors / 18 months • Smaller transistors => faster transistors (MHz -> GHz) • Many transistors => more on-chip state (caches) • Many transistors => advanced architectures (ILP++)

28. Higher clock frequencies • The increase in clock frequency came from • Faster transistors • Less work in each clock • As of ~2003 max clock frequency has mostly stalled • Some notable exceptions from IBM: Power7 5+ GHz Graph courtesy of http://smoothspan.wordpress.com/

29. More on-chip state • Development of on-chip cache sizes (L1, L2, L3) • Development of number fo physical registers • Development of other significant on-chip cache state • Branch prediction • Speculative re-order buffers etc.

30. Ways to exploit ILP Super-pipelining Pipelining Superscalar execution (also VLIW) Fetch OoO Superscalar Fetch Issue

31. Why Multicore • Because these are the only chips we know how to build with the increasing number of transistors within the power envelope • Because of performance reasons: potential of linear performance improvements with growing number of cores • If we could only program them... • Because of power reasons

32. Multicore power savings potential • Super simplified model • Requires perfect parallelisation • With lower Vdd, leakage currents increase • Vdd may not be reduced as much f’ = f/4 f V’dd= Vdd/4 Vdd P’ = P/64 P

33. Some observations... • Amount of cores is rapidly rising • I/O-devices, controllers and accelerators are moving onto the same die as processors • So far, shared address space • With some exceptions • So far, homogeneous architectures • With some exceptions

34. The Multicore Software Triad Desirable properties: • Scalable up and down • Do not introduce new bugs with parallelism • Easy to write and maintain

35. Programming model design space • General-purpose languages (GPL) • Native threads/processes • Data parallelism • SPMD • Loop-based parallelism • Task-based parallelism • Domain-specific languages (DSL) • Erlang/SDL/Matlab/Labview • GPU-languages • Automatic parallelization • Tool support

36. A coding example Serial code int fib(int n){ if (n < 2) return n; else { int x = fib(n-1); int y = fib(n-2); } return x + y; } int main(int argc, char *argv[]){ int n = atoi(argv[1]); int result = fib(n); } • Fibonacci numbers • Stupid algorithm • Good didactic example

37. Homegrown threading: pthreads int fib(int n){ if (n < 2) return n; else { int x = fib(n-1); int y = fib(n-2); } } typedef struct { int input; int output; } thread_args; void *thread_func(void *ptr){ int i=((thread_args *)ptr)->input; ((thread_args *)ptr)->output = fib(i); return NULL; } int main(int argc; char *argv[]){ pthread_t thread; thread_args args; int status, results, thread_res; int n = atoi(argv[1]); if (n < 30) result = fib(n); else { args.input = n-1; status = pthread_create( &thread, NULL, thread_func, (void*)&args); result = fib(n-2); pthread_join(thread, NULL); result += args.output; } }

38. Consequences of pthreads Desirable properties: • Scalable up and down • Code is fixed to two threads • Do not introduce new bugs with parallelism • Code no longer modular • Easy to write and maintain • 50 year leap backwards!

39. Same example using OpenMP int fib(int n){ int x, y; if (n < 2) return n; else { #pragma omp task shared(x) x = fib(n-1); #pragma omp task shared(y) y = fib(n-2); #pragma omp taskwait } return x + y; } int main(int argc; char *argv[]){ int n = atoi(argv[1]); if (n < 30) result = fib(n); else { #pragma omp parallel #pragma omp single result = fib(n); } }

40. Thread Thread Thread Thread Thread Thread Thread Thread The Shared Memory Model Shared Memory

41. $ $ $ $ $ $ $ $ $ Thread Thread Thread Thread Thread Thread Thread Thread Thread Adding Caches: More Concurrency Shared Memory

42. ... Read A … Read B … Read A Automatic Replication of Data Shared Memory A: B: $ $ $ Thread Thread Thread Read A Read A … … Read A

43. INV INV $ $ $ Thread Thread Thread ... Read A … Write A Read B … Read A The Cache Coherent Memory System Shared Memory A: B: Read A Read A … …

44. $ $ $ Thread Thread Thread The Cache Coherent Memory System Shared Memory A: B: Read A Read A … … ... Read A … Write A Read B … Read A

45. $ $ $ Thread Thread Thread The Cache Coherent Memory System Shared Memory A: B: Read A Read A … … Read A ... Read A … Write A Read B … Read A

46. Snoop-based Protocol Implementation Shared Memory BUS BUS snoop Cache A-tag S Data Bus transaction CPU access CPU

47. MOSI Protocol, 1(2) Bus Transactions BUSrts: ReadtoShare (reading the data with the intention to read it) BUSrtw, ReadToWrite (reading the data with the intention to modify it) BUSwb: Writing data back to memory BUSinv: Invalidating other caches copies CPU-Initiated Events CPUwrite: Caused by a store miss CPUread Caused by a loadmiss CPUrepl: Caused by a replacement

48. MOSI Protocol 2 (2)

49. INV INV INV Directory-based snooping Who has a copy Who has a copy A: B: $ $ $ Thread Thread Thread Read A Read A … … ... Read A … Write A Read B … Read A

50. Sammanfattning • Det finns en mängd smarta sätt att spara effekt och energi i dagens datorer • Arkitekturtrick (som t.ex. de som nämnts i denna föreläsning) • Clock and power gating: Stäng av delar av chipet som inte används • DVFS – Dynamic Voltage and Frequency Scaling: sänk klockfrekvensen (och matningsspänningen) om det inte behövs för prestanda • Parallellism är ofta en förutsättning för alla dessa tekniker • Inklusive multicore