Architetture per il calcolo parallelo

Architetture per il
calcolo parallelo
Moreno Marzolla
Dip. di Informatica—Scienza e Ingegneria (DISI)
Università di Bologna
http://www.moreno.marzolla.name/
Copyright © 2013, 2014, Moreno Marzolla, Università di Bologna, Italy
(http://www.moreno.marzolla.name/teaching/AA2014/)
This work is licensed under the Creative Commons Attribution-ShareAlike 3.0 License
(CC-BY-SA). To view a copy of this license, visit http://creativecommons.org/licenses/bysa/3.0/ or send a letter to Creative Commons, 543 Howard Street, 5th Floor, San
Francisco, California, 94105, USA.
Algoritmi Avanzati--modulo 2
2
Una architettura parallela astratta
CPU
CPU
CPU
CPU
Rete di interconnessione
Memoria
●
●
●
Memoria
Memoria
Come è gestito il parallelismo?
Dove si trova fisicamente la memoria?
Quale è la topologia della rete di comunicazione?
Algoritmi Avanzati--modulo 2
3
Perché studiamo le architetture
parallele?
●
Non esiste il “calcolatore parallelo tipico”: diversi
produttori adottano architetture diverse
–
●
●
●
Conseguentemente non esiste un singolo paradigma di
programmazione parallela valido per tutte le architetture
Il tipo di architettura parallela ha un enorme impatto
sulle prestazioni dei programmi
Sarebbe bello riuscire a descrivere algoritmi paralleli in
modo generico e indipendente dall'architettura; questo
faciliterebbe la portabilità
La triste verità è che, In generale, è necessario
utilizzare algoritmi ad-hoc in base all'architettura del
sistema su cui verranno implementati
Algoritmi Avanzati--modulo 2
4
Architettura di Von Neumann
e sue estensioni
Algoritmi Avanzati--modulo 2
5
Architettura di Von Neumann
Processore
(CPU)
Memoria
Sottosistema
di interfaccia
(I/O)
Bus di sistema
Algoritmi Avanzati--modulo 2
6
Un po' più in dettaglio
Dati
Indirizzi
Controllo
Bus
R0
R1
ALU
Memoria
Memoria
Rn
PC
IR
PSW
Controllo
Algoritmi Avanzati--modulo 2
7
Ciclo Fetch-Decode-Execute
●
●
Eseguito in continuazione dalla CPU
Fetch
–
●
Decode
–
●
Preleva dalla memoria l'istruzione da eseguire; l'istruzione
viene prelevato dall'indirizzo di memoria che si trova in PC; il
contenuto di tale cella di memoria viene posto in IR
Esamina l'istruzione che si trova memorizzata in IR per
decidere cosa fare
Execute
–
Esegue l'istruzione memorizzata in IR, incluso il recupero
dalla memoria degli eventuali parametri necessari ad
eseguirla, e deposito del risultato
Algoritmi Avanzati--modulo 2
8
Limitare i colli di bottiglia
dell'architettura di Von Neumann
●
Ridurre la latenza degli accessi alla memoria
–
●
“Nascondere” la latenza degli accessi alla memoria
–
●
Sfruttare i registri della CPU e le cache
Multithreading e context-switch durante gli accessi alla
memoria
Esecuzione di istruzioni in parallelo
–
–
–
–
–
Pipelining
Multiple issue
Branch prediction
Speculative execution
SIMD multimedia extensions
Algoritmi Avanzati--modulo 2
9
Località e parallelismo
●
●
Le memorie capienti sono lente, le memorie veloci
hanno capienza limitata
Le applicazioni dovrebbero fare il massimo uso di dati
“locali” per ottenere le migliori prestazioni
CPU
L! Cache
L2 Cache
L3 Cache
(possibile) bus di
interconnessione
Memoria
Algoritmi Avanzati--modulo 2
10
Gerarchia di cache dell'architettura
AMD Bulldozer
Fonte: http://en.wikipedia.org/wiki/Bulldozer_%28microarchitecture%29
Algoritmi Avanzati--modulo 2
11
Gerarchia di memoria CUDA
Block
Block
Shared Memory
Registers
Thread
Local
Memory
Shared Memory
Registers
Registers
Thread
Local
Memory
Thread
Local
Memory
Registers
Thread
Local
Memory
Global Memory
Constant Memory
Texture Memory
Algoritmi Avanzati--modulo 2
12
Instruction Level Parallelism (ILP)
●
Aumenta le prestazioni del processore mediante più
unità funzionali che operano contemporaneamente
–
–
Pipelining: le unità funzionali sono organizzate in “fasi”,
come una catena di montaggio
Multiple issue: le unità funzionali possono essere utilizzate in
qualsiasi ordine
●
●
Static multiple issue: l'uso delle unità funzionali è stabilito a tempo di
compilazione (esempio: Intel IA64)
Dynamic multiple issue (superscalar): l'uso delle unità funzionali è
deciso dal processore durante l'esecuzione del programma
Algoritmi Avanzati--modulo 2
13
Instruction Level Parallelism
IF
ID
IF
ID
EX
MEM
WB
EX
Integer
WB
Pipelining
Instruction Fetch
Instruction Decode
Execute
Memory Access
Write Back
Instruction Fetch
and Decode Unit
Integer
MEM
Floating
Point
Commit Unit
Multiple
Issue
In-order
issue
Floating
Point
In-order
commit
Algoritmi Avanzati--modulo 2
Load
Store
Out of order
execute
14
Speculation
●
●
Per usare la tecnica di multiple issue, il processore
deve individuare quali istruzioni possono essere
eseguite contemporaneamente
Nella esecuzione speculativa il compilatore o il
processore ipotizzano l'esito di certe operazioni in
corso (tipicamente, confronti) e in base a tale ipotesi
decidono quale istruzione successiva eseguire
Algoritmi Avanzati--modulo 2
15
Speculation
●
z = x + y;
if ( z
w
} else
w
}
> 0 ) {
= x ;
{
= y ;
●
Se il processore ritiene che il
confronto “z > 0” darà come
risultato true, inizierà ad
eseguire “w = x” prima
ancora che l'espressione “z
> 0” sia stata valutata
Se l'ipotesi si rivelasse
sbagliata, dovrà
interrompere l'esecuzione di
“w = x” ed eseguire “w = y”
Algoritmi Avanzati--modulo 2
16
Nel mondo reale...
●
Dalla documentazione di GCC
http://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html
— Built-in Function: long __builtin_expect (long exp, long c)
You may use __builtin_expect to provide the compiler with branch
prediction information. In general, you should prefer to use actual profile
feedback for this (-fprofile-arcs), as programmers are notoriously bad at
predicting how their programs actually perform. However, there are
applications in which this data is hard to collect.
The return value is the value of exp, which should be an integral
expression. The semantics of the built-in are that it is expected that exp ==
c. For example:
if (__builtin_expect (x, 0))
foo ();
Algoritmi Avanzati--modulo 2
17
Branch Hint: Esempio
#include <stdlib.h>
int main( void )
{
int A[1000000];
size_t i;
const size_t n = sizeof(A) / sizeof(A[0]);
for ( i=0; __builtin_expect( i<n, 1 ); i++ ) {
A[i] = i;
}
return 0;
}
Evitate accuratamente queste microottimizzazioni, a meno che non sappiate
esattamente cosa state facendo.
Algoritmi Avanzati--modulo 2
18
Hardware multithreading
●
Consente al processore di eseguire istruzioni anche
quando il task corrente è in stallo
–
●
Fine-grained: il context-switch tra thread ha costo
pressoché nullo e puo' quindi avvenire istruzione per
istruzione
–
●
ad esempio, perché sta aspettando dati dalla memoria
Richiede CPU con supporto specifico,e.g., Cray XMT
Coarse-grained: il context-switch avviene solo per i
thread bloccati per periodi più lunghi (es., su I/O)
–
Context switch solitamente più oneroso, minore efficienza
dell'utilizzo della CPU in presenza di stalli di breve durata
Algoritmi Avanzati--modulo 2
19
Hardware multithreading
●
●
Simultaneous multithreading (SMT) è una variazione
di fine-grained multithreading basato sul fatto che
diversi thread possono usare contemporaneamente
unità funzionali diverse
Nei sistemi SMT istruzioni di thread diversi possono
contemporaneamente essere presenti in diverse
unita' funzionali
Instruction Fetch
and Decode Unit
Integer
Floating
Point
Integer
Algoritmi Avanzati--modulo 2
Commit Unit
Floating
Point
Load
Store
20
HyperThreading
●
●
●
Implementazione recente della tecnologia SMT da
parte di Intel
Ogni core fisico presente sul processore viene visto e
gestito dal Sistema Operativo come due core logici
distinti
HT sfrutta l'architettura superscalare del processore
(cioè il fatto che alcune unità—ad esclusione dell'unità
principale di esecuzione—sono duplicate e possono
operare in parallelo)
Algoritmi Avanzati--modulo 2
21
Architetture Parallele
Algoritmi Avanzati--modulo 2
22
Architettura di
Von Neumann
Tassonomia di Flynn
Single
Multiple
Instruction Streams
Data Streams
Single
Multiple
SISD
SIMD
Single Instruction Stream
Single Data Stream
Single Instruction Stream
Multiple Data Streams
MISD
MIMD
Multiple Instruction Streams
Single Data Stream
Multiple Instruction Streams
Multiple Data Streams
Algoritmi Avanzati--modulo 2
Poco diffusi
23
SIMD
●
I sistemi SIMD consentono di applicare la stessa
istruzione (tipicamente aritmetica/logica, e.g., somma,
prodotto, …) a più dati contemporaneamente
(tipicamente, 4 oppure 8)
Questo implica che la ALU debba essere replicata
4/8/... volte
Tempo
●
LOAD A[0]
LOAD A[1]
LOAD A[2]
LOAD A[3]
LOAD B[0]
LOAD B[1]
LOAD B[2]
LOAD B[3]
C[0] = A[0] + B[0]
C[1] = A[1] + B[1]
C[2] = A[2] + B[2]
C[3] = A[3] + B[3]
STORE C[0]
STORE C[1]
STORE C[2]
STORE C[3]
Algoritmi Avanzati--modulo 2
24
SSE (Streaming SIMD Extensions)
●
●
●
Estensione al set di istruzioni x86
70 nuove istruzioni in grado di operare
prevalentemente su numeri floating point in precisione
singola
8 nuovi registri a 128 bit (XMM0—XMM7)
–
●
rappresentano 4 float a 32 bit in precisione singola
SSE2 consente di rappresentare
–
–
–
–
–
2 double a 64 bit, oppure
2 interi a 64 bit, oppure
4 interi a 32 bit, oppure
8 short int a 16 bit, oppure
16 caratteri a 8 bit
32
32
128
32
32
XMM0
XMM1
Algoritmi Avanzati--modulo
XMM72
25
SSE (Streaming SIMD Extensions)
32
32
32
32
X3
X2
X1
X0
Y3
Y2
Y1
Y0
op
op
op
op
X3 op Y3 X2 op Y2 X1 op Y1 X0 op Y0
Algoritmi Avanzati--modulo 2
26
Esempio
__m128 a = _mm_set_ps( 1.0, 2.0, 3.0, 4.0 );
__m128 b = _mm_set_ps( 2.0, 4.0, 6.0, 8.0 );
__m128 ab = _mm_mul_ps( a, b );
32
32
32
32
a
1.0
2.0
3.0
4.0
b
2.0
4.0
6.0
8.0
18.0
32.0
_mm_mul_ps( a, b )
ab
2.0
8.0
Algoritmi Avanzati--modulo 2
27
GPU
●
Le moderne GPU
(Graphics Processing
Units) includono un
elevato numero di
“core” che esibiscono
caratteristiche simili a
sistemi SIMD
Chip GPU Fermi (fonte:
28
http://www.legitreviews.com/article/1100/1/)
Algoritmi Avanzati--modulo 2
CPU vs GPU
●
Le differenze sono evidenti se consideriamo come
vengono utilizzati i transistor presenti sul chip
ALU
ALU
ALU
ALU
Control
Cache
DRAM
DRAM
CPU
GPU
Algoritmi Avanzati--modulo 2
29
GPU core
●
Un singolo core contiene
una unità fetch/decode
condivisa tra più ALU
–
●
ALU
ALU
ALU
ALU
ALU
ALU
ALU
ALU
Ctx
Ctx
Ctx
Ctx
Ctx
Ctx
Ctx
Ctx
Ctx
Ctx
Ctx
Ctx
8 ALU = ciascuna
istruzione può operare su
8 dati simultaneamente
Ogni core mantiene più
contesti di esecuzione
ed è in grado di passare
dall'uno all'altro a costo
~zero
–
Fetch / Decode
Fine-grained parallelism
Algoritmi Avanzati--modulo 2
30
GPU
●
12 stream di istruzioni x 8 ALU = 96 operazioni in
parallelo
Algoritmi Avanzati--modulo 2
31
MIMD
●
Nelle architetture MIMD sono presenti più unità di
esecuzione che eseguono sequenze di istruzioni
indipendenti
–
Ogni unità di esecuzione può operare su dati differenti
dalle altre
–
Tempo
●
Multiple Instruction Streams
Multiple Data Streams
LOAD A[0]
CALL F()
a = 18
w=7
LOAD B[0]
z=8
b=9
t = 13
C[0] = A[0] + B[0]
y = 1.7
if ( a>b ) c = 7
k = G(w,t)
STORE C[0]
z=x+y
a=a-1
k=k+1
Algoritmi Avanzati--modulo 2
32
Architetture MIMD
●
Shared Memory
–
–
●
CPU
Un insieme di processori che
condividono una memoria comune
Ogni processore puo' accedere
direttamente ad una qualsiasi
locazione della memoria
CPU
CPU
CPU
Interconnect
Memoria
Distributed Memory
–
–
–
Un insieme di sistemi autonomi
connessi tramite una rete di
comunicazione
Nodi diversi devono comunicare
tramite la rete per condividere dati
Esempio più comune: cluster di
PC connessi tramite ethernet,
programmati usando MPI
CPU
CPU
CPU
CPU
Mem
Mem
Mem
Mem
Algoritmi Avanzati--modulo 2
Interconnect
33
Architetture ibride
●
In pratica, i principali sistemi HPC presenti sul mercato
sono basati su architetture ibride, in cui ogni nodo di
calcolo è un sistema multiprocessore a memoria
condivisa, e più nodi sono collegati da una rete di
interconnessione
GPU GPU
GPU GPU
GPU GPU
GPU GPU
CPU CPU
CPU CPU
CPU CPU
CPU CPU
CPU CPU
CPU CPU
CPU CPU
CPU CPU
Mem
Mem
Mem
Mem
Interconnect
Algoritmi Avanzati--modulo 2
34
Esempio shared memory
Intel core i7
AMD “Istanbul”
Algoritmi Avanzati--modulo 2
35
Esempio distributed memory
IBM BlueGene / Q @ CINECA
Architecture
10 BGQ Frame
Model
IBM-BG/Q
Processor Type
IBM PowerA2, 1.6 GHz
Computing Cores
163840
Computing Nodes
10240
RAM
1GByte / core
Internal Network
5D Torus
Disk Space
2PByte scratch space
Peak Performance
2PFlop/s
Algoritmi Avanzati--modulo 2
36
Algoritmi Avanzati--modulo 2
37
Algoritmi Avanzati--modulo 2
38
www.top500.org
Algoritmi Avanzati--modulo 2
39
www.top500.org
Algoritmi Avanzati--modulo 2
40
SANDIA ASCI RED
Data:
1996
Prestazioni di picco:
1.8Teraflops
Ingombro:
150m2
Consumo
energetico:
800.000 Watt
Algoritmi Avanzati--modulo 2
41
SANDIA ASCI RED
Data:
1996
Prestazioni di picco:
1.8Teraflops
Ingombro:
150m2
Consumo
energetico:
800.000 Watt
Sony
PLAYSTATION 3
Data:
2006
Prestazioni di picco:
>1.8Teraflops
Ingombro:
0.08m2
Consumo
energetico:
<200 Watt
Algoritmi Avanzati--modulo 2
42
Dentro la PS3
Cell Broadband Engine
Algoritmi Avanzati--modulo 2
43
Conclusioni
●
●
Memoria condivisa
Vantaggi:
–
–
●
●
●
In generale, più “facile” da
programmare
Vantaggioso per applicazioni
che prevedono un accesso
“irregolare” ai dati (esempio,
algoritmi di esplorazione di
grafi)
Svantaggi:
–
–
–
–
●
Problemi di concorrenza/mutua
esclusione
Banda di memoria limitata
Memoria distribuita
Vantaggi:
Accesso a potenze di calcolo
molto elevate
Vantaggioso per applicazioni
che esibiscono forte località di
accesso ai dati, con elevato
rapporto computazione /
comunicazione
Svantaggi:
–
–
Latenza della rete di
comunicazione
In generale, più complesso da
programmare
Algoritmi Avanzati--modulo 2
44