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

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?

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

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

Vad tar energi? Mikroprocessorer är byggda av CMOS transistorer Kretsen visar en inverterare -In = 0 => Out = 1 -In = 1 => Out = 0 V dd InOut = 0 = 1

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) V dd InOut = 0 = 1 C N P

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

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 V dd 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! V dd In → 0 = 0 = 1 Out → 1 N Opens P Closes

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 V dd InOut = 0 = 1

CMOS Effektförbränning (nästan)  är en aktivitetsfaktor C är den samlade kapacitansen V dd är matsningsspänningen f är klockfrekvensen I leak är de samlade läckströmmarna Eftersom f  V dd (inom vissa gränser)  P  V dd 3

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

4-way set associative cache memory All läsning och skrivning i minnesceller drar energi!

Tekniker för att minska energin i cacheminnen Mängd-associativa cacheminnen har bra prestanda, men de drar mycket energi Access till datadelen drar mycket mer energi än till adressetiketterna. (Varför?) -De flesta optimeringar görs för datadelen Olika tekniker: -Fasad access -Sekventiell access -Way prediction

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 Figurer från Kaxiras & Martonosi, COMPUTER ARCHITECTURE TECHNIQUES FOR POWER-EFFICIENCY

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

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 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

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

CGO Paper

Multicore processors Why and How

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

The Free Lunch ? SPEC INT CPU 2000 Not so exponential increase in speed

2012 state-of-the-art, high-end Intel Sandybridge, 6 cores, 12 threads, 130 W Intel Xeon E7, 10 cores, 20 threads, 105 W AMD Opteron cores, 16 threads, 140 W Oracle UltraSparc T5 16 cores, 128 threads

2012 state-of-the-art, embedded Freescale T cores, 24 threads, 35 W Nvidia Tegra cores+acc, 1-2 W Tilera Tile-GX 100 cores, 50 W Adapteva Epiphany-IV 64 cores, 2 W

We’re going manycore

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

Software development == Development for Multicore Software development == Development for Multicore

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++)

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

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.

Ways to exploit ILP PipeliningSuper-pipelining Fetch Superscalar execution (also VLIW) Fetch OoO Superscalar Issue

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

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

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

The Multicore Software Triad Application performance Software Reliability Development time Desirable properties: Scalable up and down Do not introduce new bugs with parallelism Easy to write and maintain

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

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

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; }

Consequences of pthreads Application performance Software Reliability Development time 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!

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); }

The Shared Memory Model Thread Shared Memory

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

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

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

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

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

Shared Memory Snoop-based Protocol Implementation A-tagSData CPU access BUS snoop CPU BUS Cache Bus transaction

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 MOSI Protocol, 1(2)

MOSI Protocol 2 (2)

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

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

Research orientation Why, Analysis, Evaluation Basics IS1{2/5}00 ID1217 IS2202IS2205IS2200IS2205 Anknytande kurser IS1200/1500: Datorteknik och komponenter ID1217: Programmering med parallella processer (p3) IL2206 Inbyggda system (p1) ID2202: Kompilatorer och exekveringsmiljöer (p2) IS2202 Datorsystemarkitektur (p4 Kista) IS2200: Parallella datorsystem (p2 Campus Vv) IL2212 Programvara för inbyggda system (p3) IS2205: Individuella studier i datorsystem Examensarbete (kand & master)