Modelli di programmazione parallela Message-passing vs Shared-memory Salvatore Orlando

Transcript

1 Modelli di programmazione parallela Message-passing vs Shared-memory Salvatore Orlando 1

2 Message-passing 2

3 Message Passing Linguaggi o librerie? Linguaggi con costrutti per MP non hanno sortito grande successo CSP, OCCAM Un linguaggio permette di effettuare a compile-time controlli quali il type-checking o l analisi dei deadlock es. una send che non possiede una matching receive rispetto ai tipi dei dati scambiati in OCCAM questo check è semplificato. bisogna definire dei canali di comunicazione tipati, da passare come parametro ai processi comunicanti, il tutto staticamente le librerie non permettono questo tipo di analisi statiche grazie alla loro flessibilità, sono però facilmente portabili e incontrano il favore degli sviluppatori di sw parallelo Librerie sono linkabili a linguaggi sequenziali MPI (Message Passing Interface) PVM (Parallel Virtual Machine) Versioni disponibli per C/C++ e F77 Disponibili su cluster o MPP versioni ottimizzate rispetto alle reti SAN, versioni sopra TCP/IP 3

4 MPI e PVM MPI (Message Passing Interface) standard sviluppato da ricercatori e industrie espressamente per il calcolo parallelo esistono diverse implementazioni free della libreria mpich - disponibile da Argonne National Laboratories PVM (Parallel Virtual Machine) prima libreria MP largamente adottata uso di COW come piattaforma multicomputer calcolo distribuito e parallelo sviluppato da Oak Ridge National Laboratories macchine omogenee o eterogenee collezione di routine linkabili con C o Fortran pubblico dominio 4

5 Meccanismi basici Creazione di processi A tempo di load creazione semi-statica, numero dei processi stabilito al caricamento SPMD è l approccio seguito dagli ambienti basati su MPI, disponibile ora anche per PVM adatto per implementare data parallelism A tempo di esecuzione ovvero creazione dinamica di un processo, dato un eseguibile è l approccio seguito da PVM (spawn) in principio, processi con codici e dati diversi (MPMD) A tempo di compilazione approccio vecchio, tutto stabilito staticamente (numero e mapping dei processi) OCCAM su Meiko CS1 - Transputer linguaggio per definire mapping dei diversi processi (MPMD) e dei canali rispettivamente sui nodi di elaborazione e sui link fisici approccio popolare su macchine dove il mapping dei processi era importante per rendere locali le comunicazioni routing hw assente 5

6 SPMD Compilazione diversa, se macchine eterogenee EXE Caricamento su n processori (reali o virtuali) di processi, caratterizzati dallo stesso codice Machine 0 Machine n 6

7 MPMD dinamico Tempo EXE1 EXE2 spawn() Processo 0 Processo 1 7

8 Meccanismi basici Invio e ricezione di messaggi convenzione sul naming dei partner scambio di messaggi tra gruppi di processi operazioni collettive dati tipati marshaling su architetture eterogenee messaggi tipati tag associati ai messaggi primitive sincrone/asincrone e bloccanti/non bloccanti ricezione non deterministica di messaggi 8

9 Naming processi Nelle librerie i processi sono nominati tramite identificatori numerici (rank, tid, pid) SPMD esistono routine per permettere di conoscere il proprio ID il range degli ID (numero di processi allocati) sw flessibile Creazione dinamica le routine che effettuano lo spawn restituiscono gli ID dei processi creati (tipo fork()) Ricezione non deterministica wild card nella receive(), per poter ricevere da uno qualsiasi dei possibili mittenti 9

10 Tipi di scambio di messaggi Sincrono senza buffer di sistema, bloccante send() non può avvenire se il ricevente non è ancora giunto sulla corrispondente receive() realizza contemporaneamente comunicazione e sincronizzazione Idling e deadlock sono i problemi maggiori con le send sincrone 10

11 Esempio di protocollo per sincronizzazione 11

12 Tipi di scambio di messaggi Asincrono o buffered le send() restituiscono subito il controllo al processo sender il msg viene copiato in buffer di sistema il msg può giungere sull host del processo ricevente ed essere copiato in un buffer, anche se il processo receiver non ha ancora effetuato la recv() buffer di grandezza finita controllo del flusso può bloccare il mittente 12

13 Buffering Questo è quello che tipicamente succede quando si usa una primitiva buffered Process 0 Process 1 User data Local buffer the network Local buffer User data 13

14 Evitare il buffering In generale sarebbe meglio evitare le copie, che introducono overhead. User data Process 0 Process 1 the network User data Questo richiede che - la Send attenda prima di inviare (sincrono), oppure - che la Send ritorni prima del completamento (comportamento non bloccante: dobbiamo avere un modo di testarne più tardi il completamento). 14

15 Blocking vs Unblocking Sia nel caso buffered/asincrono e sia nel caso unbuffered/sincrono receive() sono comunque bloccanti Le send() buffered/asincrone spesso definite non bloccanti, ma non in MPI In MPI, sono definite bloccanti anche le routine buffered/asincrone nel senso che sono bloccate nell attesa di fornire i dati al sottosistema di comunicazione, ovvero nell attesa di copiare il messaggio in un buffer di sistema Routine MPI non bloccanti ritornano subito la send() ritorna subito, e il dato non viene copiato in un buffer di sistema la recv() ritorna subito, anche se il msg atteso non è ancora giunto la memoria utente riferita nelle routine non può però essere riusata fino Completamento invio messaggio Completamento ricezione messaggio esistono routine per controllare (polling) la terminazione dell operazione (receive) o liberazione della memoria (send) si evitano le copie ma non solo 15

16 Primitive non-bloccanti Senza hardware apposito (a) il vantaggio è nel fatto che il sender/receiver possono continuare a lavorare Con hardware di comunicazione dedicato (b), il tempo di tramissione e copia nello spazio utente del ricevente viene sovrapposto completamente con calcolo utile 16

17 Messaggi e dati tipati Tag identificatori numerici, con cui tipare (taggare) i msg permettono di differenziare tra msg inviati tra coppie di processi Data types Esistono datatypes per tutti i datatype del C datatypes MPI_BYTE corrisponde al byte (8 bits) MPI_INT corrisponde al signed int MPI_LONG corrisponde al signed long int ecc. 17

18 Esempio routine MPI Standard Comunicazione asincrona, buffered dal sistema, bloccante (definizione alla MPI) nota l uso dei comunicatori (il cui significato sarà chiaro nel seguito) 18

19 MPI communication modes Oltre alla modalità Standard, MPI fornisce diverse modalità per mandare messaggi: Modo sincrono (MPI_Ssend): la send non completa fino a che una receive corrispondente è iniziata (deadlock.) Modo buffered (MPI_Bsend): qui è l utente che fornisce il buffer al sistema per il suo uso. (Attenzione, l utente deve allocare abbastanza buffer per evitare che i programmi si blocchino). Ready mode (MPI_Rsend): l utente è sicuro che la receive corrispondente è già stata inviata L idea di questa modalità è permettere l accesso a protocolli veloci Il comportamento della primitiva non è definito se il matching receive non è stato inviato Per tutte le modalità abbiamo le versione non-bloccanti MPI_Recv riceve messaggi inviati in qualsiasi modalità 19

20 Wildcard, non determinismo ecc. Wildcards Il processo ricevente può specificare wildcard per il source e il tag, per ricevere in modo non deterministico da più sorgenti, indipendentemente dal tag MPI_ANY_SOURCE MPI_ANY_TAG Message length Il count sul processo ricevente deve essere sufficiente per ricevere il messaggio Ovvero, maggiore o uguale alla lunghezza del messaggio in arrivo Check successivo per determinare le caratteristiche del msg ricevuto 20

21 Recv: status Status è una struttura dati allocata nello user s program, che conterrà informazioni sulla receive appena conclusa: int recvd_tag, recvd_from, recvd_count; MPI_Status status; MPI_Recv(..., MPI_ANY_SOURCE, MPI_ANY_TAG,..., &status ) recvd_tag = status.mpi_tag; recvd_from = status.mpi_source; MPI_Get_count( &status, datatype, &recvd_count ); 21

22 Richiedere informazioni al supporto di MPI Le funzioni MPI_Comm_size e MPI_Comm_rank servono per conoscere il numero dei processi (all interno del comunicatore) l identificatore del processo chiamante (all interno del comunicatore) int MPI_Comm_size(MPI_Comm comm, int *size) int MPI_Comm_rank(MPI_Comm comm, int *rank) Il rank è un identificatore intero che va 0 a size-1, dove size è il numero di processi nel comunicatore 22

23 Esempio routine non bloccanti MPI_Isend(buf, count, datatype, dest, tag, comm,request) MPI_Irecv(buf, count, datatype, source, tag, comm,request) Il completamento delle due routine può essere controllato tramite MPI_Wait() e MPI_Test() MPI_Wait() è l attesa bloccante, e ritorna solo quando la send/receive è stata completata MPI_Test() serve per fare il polling, ovvero ritorna un flag che, se settato, indica che l operazione è stata completata 23

24 Esempio d uso di primitiva non bloccante In alcune implementazioni dovrebbe permettere un migliore sovrapposizione tra calcolo e comunicazione es. se il sottosistema di comunicazione è in grado di accedere direttamente in DMA al buffer utente (x) mentre il programma utente è in esecuzione MPI_Comm_rank(MPI_COMM_WORLD, &myrank); /* find process rank */ if (myrank == 0) { int x; MPI_Isend(&x, 1, MPI_INT, 1, msgtag, MPI_COMM_WORLD, req1); compute(); MPI_Wait(req1, status); } else if (myrank == 1) { int x; MPI_Recv(&x, 1, MPI_INT, 0, msgtag, MPI_COMM_WORLD, status); } Nota l uso combinato di Send non bloccante e Recv bloccante 24

25 Evitare i deadlock Considera: int a[10], b[10], myrank; MPI_Status status;... MPI_Comm_rank(MPI_COMM_WORLD, &myrank); if (myrank == 0) { MPI_Send(a, 10, MPI_INT, 1, 1, MPI_COMM_WORLD); MPI_Send(b, 10, MPI_INT, 1, 2, MPI_COMM_WORLD); } else if (myrank == 1) { MPI_Recv(b, 10, MPI_INT, 0, 2, MPI_COMM_WORLD); MPI_Recv(a, 10, MPI_INT, 0, 1, MPI_COMM_WORLD); }... Se MPI_Send è bloccante/sincrona, c è sicuramente un deadlock. 25

26 Evitare i deadlock Considera il seguente codice, in cui il Processo i invia un messaggio al Processo i + 1 (modulo il numero di processi) e riceve un messaggio dal Processo i - 1 (modulo il numero di processi). int a[10], b[10], npes, myrank; MPI_Status status;... MPI_Comm_size(MPI_COMM_WORLD, &npes); MPI_Comm_rank(MPI_COMM_WORLD, &myrank); MPI_Send(a, 10, MPI_INT, (myrank+1)%npes, 1, MPI_COMM_WORLD); MPI_Recv(b, 10, MPI_INT, (myrank-1+npes)%npes, 1, MPI_COMM_WORLD);... Abbiamo ancora un deadlock se MPI_Send è blocc. / sincrona 26

27 Evitare i deadlock Possiamo interrompere l attesa circolare che causa il deadlock come segue: int a[10], b[10], npes, myrank; MPI_Status status;... MPI_Comm_size(MPI_COMM_WORLD, &npes); MPI_Comm_rank(MPI_COMM_WORLD, &myrank); if (myrank%2 == 1) { MPI_Send(a, 10, MPI_INT, (myrank+1)%npes, 1, MPI_COMM_WORLD); MPI_Recv(b, 10, MPI_INT, (myrank-1+npes)%npes, 1, MPI_COMM_WORLD); } else { MPI_Recv(b, 10, MPI_INT, (myrank-1+npes)%npes, 1, MPI_COMM_WORLD); MPI_Send(a, 10, MPI_INT, (myrank+1)%npes, 1, MPI_COMM_WORLD); }... 27

28 Gruppi e Comunicatori Nelle chiamate alle routine si riferisce l identificatore del gruppo tag e rank fanno riferimento al particolare gruppo In MPI i vari gruppi sono identificati dai comunicatori Definiscono la portata di un operazione di comunicazione I processi possono far parte di più comunicatori e avere ID (rank) diversi per ogni comunicatore All inizio, tutti processi appartengono all MPI_COMM_WORLD rank in un comunicatore sono numeri compresi tra 0 e n-1 Possibili creare comunicatori a run-time con operazioni collettive I comunicatori permettono il progetto modulare delle componenti parallele es.: applicazione SPMD che chiama una routine di libreria parallela (anch essa SPMD) senza comunicatori, diventa importante che i tag usati nella libreria siano distinti da quelli usati nel resto dell applicazione se la libreria usa un diverso comunicatore, può usare tag arbitrari nello scambio dei messaggi 28

29 Uso dei comunicatori: librerie MP Programma SPMD su 3 nodi Subroutine Sub1() e Sub2(), corrispondenti a librerie MPI diverse Nota: subroutine chiamate da tutti i processi (codice SPMD) Funzionamento corretto: 29

30 Uso dei comunicatori: librerie MP Usando lo stesso comunicatore, a causa dell uso di ANY_TAG, il funzionamento potrebbe essere scorretto: 30

31 Operazioni collettive Operazione collettiva coinvolge tutti i processi di un gruppo (comunicatore) tutti devono invocarla Un esempio di semplice operazione collettiva è la sincronizzazione di barriera: int MPI_Barrier(MPI_Comm comm) 31

32 Broadcast/Multicast In MPI, bcast() è un operazione collettiva int MPI_Bcast (void *buf, int count, MPI_Datatype datatype, int source, MPI_Comm comm) 32

33 Gather Un processo raccoglie (colleziona) i vari pezzi di una struttura dati int MPI_Gather(void *sendbuf, int sendcount, MPI_Datatype senddatatype, void *recvbuf, int recvcount, MPI_Datatype recvdatatype, int target, MPI_Comm comm) 33

34 Scatter Il contrario della gather int MPI_Scatter(void *sendbuf, int sendcount, MPI_Datatype senddatatype, void *recvbuf, int recvcount, MPI_Datatype recvdatatype, int source, MPI_Comm comm) 34

35 Reduce Non solo comunicazione (una sorta di gather), ma anche esecuzione di un operazione associativa sui dati (es. prodotto, somma, ecc.) potrebbe essere implementata in maniera ottimizzata, evitando di far eseguire tutto il calcolo al Processo 0 (root) riduzioni parziali possono essere effettuate dai vari processi grazie alla proprietà associativa dell operazione int MPI_Reduce(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, int target, MPI_Comm comm) 35

36 Operazioni di Riduzione Predefinite Operation Meaning Datatypes MPI_MAX Maximum C integers and floating point MPI_MIN Minimum C integers and floating point MPI_SUM Sum C integers and floating point MPI_PROD Product C integers and floating point MPI_LAND Logical AND C integers MPI_BAND Bit-wise AND C integers and byte MPI_LOR Logical OR C integers MPI_BOR Bit-wise OR C integers and byte MPI_LXOR Logical XOR C integers MPI_BXOR Bit-wise XOR C integers and byte MPI_MAXLOC max-min value-location Data-pairs MPI_MINLOC min-min value-location Data-pairs 36

37 Riduzione MPI_MAXLOC e MPI_MINLOC L operazione MPI_MAXLOC combina coppie di valori (v i, l i ) e ritorna la coppia (v, l) tale che v è il massimo tra tutti i v i l è il corrispondente l i Se ci fosse più di un massimo, verrebbe ritornato il più piccolo tra tutti gli l i MPI_MINLOC fa la stessa cosa, eccetto che individua il minimo valore v i 37

38 Operazioni collettive All_* Se tutti devono ricevere i risultati di una cerca operazione collettiva int MPI_Allreduce(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm) int MPI_Allgather(void *sendbuf, int sendcount, MPI_Datatype senddatatype, void *recvbuf, int recvcount, MPI_Datatype recvdatatype, MPI_Comm comm) All-to-all personalized communication invia un messaggio distinto da ogni processo ad ogni altro processo Il j-esimo blocco di dati in output (sendbuf) inviato dal task i è ricevuto dal task j e posto nel i-esimo blocco del buffer di ricezione (recvbuf) int MPI_Alltoall(void *sendbuf, int sendcount, MPI_Datatype senddatatype, void *recvbuf, int recvcount, MPI_Datatype recvdatatype, MPI_Comm comm) 38

39 Hello World in MPI #include <mpi.h> main(int argc, char *argv[]) { int npes, myrank; MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &npes); MPI_Comm_rank(MPI_COMM_WORLD, &myrank); printf("from process %d out of %d, Hello World!\n", myrank, npes); MPI_Finalize(); } MPI_Init deve essere chiamato prima di invocare altre routine MPI. Il suo scopo è quello di inizializzare l ambiente MPI. MPI_Finalize è chiamato alla fine della computazione, e si occupa di compiti si clean-up per terminare la sessione dell ambiente MPI. 39

40 Esempio di programma I processi determinano il proprio rank e si differenziano su questa base main (int argc, char *argv[]) { MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &myrank); if (myrank == 0) master(); else slave(); MPI_Finalize(); } 40

41 Topologie ed Embedding MPI permette ai programmatori di organizzare i processi in mesh logiche a n dimensioni I processi in MPI_COMM_WORLD (che potremmo considerare un mesh 1-dimensionale) possono essere mappati, in modi differenti, su specifici comunicatori, che corrispondono alle topologie a mesh a n dimensioni (n > 1). mapping tra rank in comunicatori differenti La qualità di tale mapping è determinata dal mapping successivo sulla topologia della macchina, che tenga conto del particolare pattern di interazione dettato dalla topologia di comunicazione 41

42 Topologie ed Embedding 42

43 Creazione e Uso delle Topologie Cartesiane E possibile creare topologie cartesiane usando: int MPI_Cart_create(MPI_Comm comm_old, int ndims, int *dims, int *periods, int reorder, MPI_Comm *comm_cart) Crea un nuovo comunicatore a partire dal vecchio, con ndims dimensioni Ogni processore identificato nella nuova topologia cartesiana da un vettore di ndims dimensioni Il size max per ogni dimensione i è dato da dims[i] il k dei k-ary n-cube Se periods [i] è!= 0, allora la topologia ha una connessione wraparound sulla dimensione i Se reorder=true, la funzione riordina i processi per scegliere un buon embedding della topologia virtuale su quella fisica parametro spesso ignorato 43

44 Creazione e Uso delle Topologie Cartesiane Per inviare e ricevere messaggi, è ancora ancora necessario usare i rank (uni-dimensionali). MPI fornisce routine per convertire rank a coordinate cartesiane e viceversa. Rank Coordinate cartesiane int MPI_Cart_coord(MPI_Comm comm_cart, int rank, int maxdims, int *coords) Coordinate cartesiane Rank int MPI_Cart_rank(MPI_Comm comm_cart, int *coords, int *rank) 44

45 Creazione e Uso delle Topologie Cartesiane L operazione più comune sulle topologie cartesiane è lo shift. Per determinare il rank della sorgente e destinazione di uno shifts, MPI fornisce la funzione seguente: int MPI_Cart_shift(MPI_Comm comm_cart, int dir, int s_step, int *rank_source, int *rank_dest) dir è la dimensione lungo cui si vuole effettuare lo shift s_step indica invece la dimensione dello shift 45

46 MPI-2 One sided communication (remote memory access) MPI Get - remote read (non richiede una matching send) MPI Put - remote write (non richiede una matching recv) MPI Accumulate - remote update, reduction Si definisce una regione nella memoria locale disponibile per accessi remoti, solo un processo deve esplicitamente partecipare. comunicazione e sincronizzazione sono disaccoppiate Process 0 Process 1 Put(data) (memory) (memory)! Get(data) 46

47 MPI-2 Thread e MPI sarebbe utile avere processi multi-threaded, anche in MPI in questo modo una chiamata bloccante bloccherebbe solo un thread non tutte le implementazioni sono purtroppo thread-safe in MPI-2 esistono primitive specifiche per gestire i thread Creazione / Terminazione dinamica di processi In modo simile al PVM I/O parallelo Bindings anche per C++/ Fortran-90 47

48 MPICH MPICH è un implementazione portabile di MPI 1 con alcune nuove primitive MPI-2 Funziona su MPPs, Grid, cluster, e NOWs o Clumps eterogenei Per compilare, eseguire e analizzare le prestazioni mpicc o myprog myprog.c mpirun -np 10 myprog 48

49 MPICH (compilazione) Esistono quindi diversi script per compilare e linkare (librerie e path relativi, path degli include sono specificati dagli script) C (mpicc) C++ (mpicc) Fortran 77 (mpif77) Fortran 90 Script di compilazione permettono diverse opzioni: esempio: -mpilog Costruisce eseguibile che genera MPE log files. Possibile linkare altre librerie 49

50 MPICH (esecuzione) mpirun [mpirun_options...] <progname> [options...] Alcune mpirun_options: -machinefile <machine-file name> Take the list of possible machines to run on from the file <machine-file name>. This is a list of all available machines; use -np <np> to request a specific number of machines. -np <np> specify the number of processors to run on -nolocal don t run on the local machine -t Testing - do not actually run, just print what would be executed In un cluster di workstation i processi di un job parallelo sono fatti partire individualmente su ciascuna workstation Se il parametro machinefile non è specificato, mpich cerca una lista di default: machines.<arch> nella directory di istallazione (es.: /usr/local/mpich2.2.21). 50

51 MPICH (machinefile) E possibile costruire un file delle workstation (machinefile) personale Esempio di machinefile: mercury venus earth mars:2 jupiter:4 che specifica l esistenza di 3 macchine con processore singolo (mercury, venus, and earth), una macchina con 2 processori (mars), e una con 15 (jupiter). Eseguendo: mpirun -np 9... con il file di sopra, verranno creati 1 processo su mercury, venus, e earth 2 su mars 4 su jupiter Se fossero necessari 10 o più processi, mpirun ripartirebbe dall inizio del file, creando processi aggiuntivi su mercury, venus, ecc. 51

52 PVM All inizio bisogna far partire la macchina virtuale daemon su ogni macchina tramite console è possibile interagire con i daemon, e gestire i task concorrenti è possibile allocare più task sulla stessa WS 52

53 PVM story Il progetto PVM è stato iniziato nell 1989 all Oak Ridge National Laboratory Sistema prototipale (non rilasciato), PVM 1.0, progettato da Vaidy Sunderam e Al Geist La versione 2 di PVM è stata scritta all Università del Tennessee (Dongarra e altri) Versione di pubblico dominio rilasciata nel 1991 Negli anni successivi PVM ebbe un grande successo E stato via via riscritto, e la versione descritta nel libro su PVM (3.0) è stata completata nel Febbraio 1993 La versione attuale: Sia per Windows che per Unix Nuove caratteristiche: contesti di comunicazione, messaggi persistenti, interoperabilità tra cluster Windows e Unix clusters. 53

54 L architettura di PVM pvmd - one PVM daemon per host libpvm - task linked to PVM library host (one per IP address) task task task tcp direct connect pvmd Unix Domain Sockets inner host messages OS network interface pvmds fully connected using UDP task task task task task task task task task internal interconnect distributed memory MPP pvmd task task task P0 P1 P2 pvmd Shared Memory shared memory multiprocessor La collezione di PVMD comunicanti definisce la Virtual Machine (VM). 54

55 Step 1 Enrolling in PVM I tasks devono esser arruolati (enrolled) nella VM per essere indirizzati myid = pvm_mytid(); printf( -> %x, myid); -> 0x40001 La prima chiamata a ogni funzione PVM arruola il task nella VM La prassi è quella di chiamare pvm_mytid() come prima invocazione di PVM 55

56 Inviare e ricevere messaggi Inviare un messaggio err = pvm_send( dest, tag ); Dest = TID of destination; Tag = user-defined distinguishing integer; Ricevere un messaggio Err = pvm_recv( src, tag ); Src = TID of sender Tag = distinguished integer 56

57 Wildcard in ricezione Wildcard sono possibili per il tid del sender task, o per il matching tag. La wildcard è -1 Any sender, specific tag pvm_recv(-1, tag); Specific sender, any message pvm_recv(src, -1); Any sender, any message pvm_recv(-1, -1); 57

58 PVM Console Quando si esegue pvm per lanciare la console Se non ci sono VM attive per il particolare utente, fa partire una nuova VM Un demone pvmd è fatto partire sulla macchina Se esiste già una VM, la console si arruola nella VM e attende comandi La console pvm è esattamente un altro programma pvm. Ogni cosa che può essere fatta dalla console, può essere fatta dal programma con apposite API 58

59 PVM Console pvm> alcuni comandi e loro significato add hostname conf delete hostname halt help [command] kill tid ps -a quit reset spawn trace version Add host(s) to virtual machine (can list several) list hosts in the virtual machine delete hosts from virtual machine shut down PVM and tasks print information about commands and options kill a task list all running tasks exit console - leave PVM and tasks running kill all tasks and reset PVM spawn tasks (many options) set/display trace events print PVM version 59

60 Shared-memory 60

61 Shared memory Programmazione di multiprocessori SM, es. SMP linguaggi Java, Modula-3 hanno costrutti espliciti per programmazione multithreading librerie pthread disponibili sulla maggior parte delle piattaforme Thread vs Processo i thread sono processi leggeri ogni processo può avere più thread, ma non viceversa i thread condividono lo stesso spazio di indirizzamento fisico (stessa tabella di pagine) Processi in principio non condividono lo stesso spazio di indirizzamento fisico spawned con la fork costituiscono unità di scheduling Preemptive e priority-based scheduling costituiscono un unità di ownership di risorse program code, program counter, heap memory, program code, program counter, stack memory, stack pointer, file descriptors, virtual memory table, signal table, etc. 61

62 Thread Unità di ownership processo Unità di scheduling thread politiche di scheduling ad-hoc Ogni thread flusso di esecuzione separato possiede quindi private program counter, stack memory, stack pointer, signal table pointer, signal table tabella delle pagine è invece globale ai vari thread dello stesso processo shared memory Nome alternativo per i thread: lightweight process Oltre ai pthread (POSIX), esistono altre librerie Solaris threads, Linux threads, DCE threads, Win32 e OS/2 threads, GNU Portable threads 62

63 Processi vs Thread Processo Thread 63

64 pthread POSIX.1c standard interfaccia per il C pthreads come peers non c è una relazione esplicita parent-child concetto di thread master (quello iniziale) vantaggi rispetto ai processi shared memory (stesso spazio virtuale e fisico tra i thread) memoria non viene swapped out in seguito al contex switch di un thread in generale, semplice condivisione risorse tra thread anche file contex-switch più veloce modificare la tabella delle pagine può essere costoso (es. TLB flush) sharing e comunicazione senza system call semplicemente leggendo/scrivendo in memoria 64

65 Gestione dei pthread pthread_create crea un thread fa partire l esecuzione di una funzione (stack privato) passa i parametri (singolo parametro puntatore) pthread_join attende la fine di un thread raccoglie il valore di ritorno 65

66 Hello world #include <stdio.h> #include <pthread.h> #define NUM_THREADS 4 Thread principale main() { int i; pthread_t tid[num_threads]; } for (int i = 0; i < NUM_THREADS; i++) pthread_create(&tid[i], NULL, hello, NULL); for (int i = 0; i < NUM_THREADS; i++) pthread_join(&tid[i], NULL); hello() { printf( Hello, World\n ); } Processo 66

67 Parallelizzazione con pthread Assegnazione delle unità di lavoro ai thread statica data parallelism, dove una struttura dati viene suddivisa tra i thread dinamica (work pool) coda condivisa il master si occupa della terminazione Condivisione su dati condivisi sono possibili race condition mutua esclusione lock (MUTEX) semaforo binario lock/unlock a carico del programmatore un solo thread può essere in esecuzione in regione critica i thread che trovano il MUTEX occupato sono bloccati, e sono svegliati dalla unlock 67

68 Data Parallelism (approccio statico) Somma di un array: int array_sum(int n, int data[]) { int mid; int low_sum, high_sum; } mid = n/2; low_sum = 0; high_sum = 0; // I due for seguenti sono indipendenti { for (int i = 0; i < mid; i++) low_sum = low_sum + data[i]; for (int j = mid; j < n; j++) high_sum = high_sum + data[j]; } return low_sum + high_sum; 68

69 Data Parallelism (approccio statico) typedef struct { int n, *data, mid; int *high_sum, *low_sum; } args_block; void sum_0(args_block *args) { for (int i = 0; i < args->mid; i++) *(args->low_sum) = *(args->low_sum) + (args->data[i]); } attributes Routine to execute void sum_1(args_block *args) { for (int j = args->mid; j < args->n; j++) *(args->high_sum) = *(args->high_sum) + args->data[j]; int array_sum(int n, int data[]) } { int mid; int low_sum, high_sum; args_block args; pthread_t threads[2]; mid = n/2; args.n = n; args.data = data; args.mid = mid; args.low_sum = &low_sum; args.high_sum = &high_sum; Thread args pthread_create(&thread[0], NULL, (void *) sum_0, (void *) &args); pthread_create(&thread[1], NULL, (void *) sum_1, (void *) &args); for (i = 0; i < 2; i++) /* wait for threads to complete */ } pthread_join(&thread[i], &retval); return low_sum + high_sum; 69

70 Mutex pthread_mutex_lock(mutex) pthread_mutex_unlock(mutex)... pthread_mutex_t printlock =PTHREAD_MUTEX_INITIALIZER;... hello() { } pthread_mutex_lock(&printlock); printf( Hello, World\n ); pthread_mutex_unlock(&printlock); 70

71 Mutex non sufficiente Spesso un thread deve controllare in sezione critica (leggendo dei dati condivisi) se un certo evento si è verificato questo evento potrebbe dipendere da un altro thread l altro thread dovrebbe poter accedere in sezione critica ai dati condivisi => per segnalare (scrivere) l evento es. 2 thread: produttore/consumatore l evento per il consumatore è la presenza di almeno 1 dato da consumare l evento per il produttore è la presenza di almeno 1 spazio libero nel buffer condiviso Soluzione naive con attesa attiva: il thread continua ad accedere in sezione critica, sperando che nel frattempo l altro thread riesca ad entrare in sezione critica per segnalare la produzione l evento Soluzione ottimale: il thread verifica che l evento non si è ancora verificato, e si sospende (block) il thread genera l evento e sveglia i thread in eventuale attesa dell evento 71

72 Esempio di Prod/Cons con soli Mutex Lock Vincoli del Produttore/Consumatore: i thread produttori non devono sovrascrivere locazioni del buffer condiviso, non consumate da qualche consumatore I thread consumatori non possono prelevare dati dal buffer finché non questo è vuoto produttori e consumatori devono operare uno alla volta per non rischiare di rendere non coerenti la struttura dati buffer Esempio naive con buffer ad una sola posizione, con soli Mutex Lock pthread_mutex_t task_queue_lock;! int task_available;!...! main() {!...! task_available = 0;! pthread_mutex_init(&task_queue_lock, NULL);!...! } 72

73 Esempio di Prod/Cons con soli Mutex Lock void *producer(void *producer_thread_data) {!...! while (create_task(&my_task)!= NULL) {! while (1) {! pthread_mutex_lock(&task_queue_lock);! if (task_available == 0) {! insert_into_queue(my_task);! task_available = 1;!!!pthread_mutex_unlock(&task_queue_lock);!!!break;! }! else!!!pthread_mutex_unlock(&task_queue_lock);! }! }! }! 73

74 Esempio di Prod/Cons con soli Mutex Lock void *consumer(void *consumer_thread_data) {! struct task my_task; /* local data structure declarations */!...! while (!done()) {! while (1) {! pthread_mutex_lock(&task_queue_lock);! if (task_available == 1) {! extract_from_queue(&my_task);! task_available = 0;!!!pthread_mutex_unlock(&task_queue_lock);!!!break;! }! else!!pthread_mutex_unlock(&task_queue_lock);! }! done = process_task(my_task);! }! }! 74

75 Condition variables Per ogni evento, è possibile definire una condition variable se una certa conditional expression non è verificata, l evento NON è ancora avvenuto blocco sulla condition variable (wait) il thread che ha generato l evento controllato, rendendo la conditional expression verificata, sveglia eventuali thread bloccati sveglia sulla condition variable (signal) Condition variable associata a un mutex se un thread si blocca sulla condizione, deve liberare la sezione critica wait ha quindi un ulteriore parametro (mutex) semantica: block + unlock(mutex) signal il thread bloccato si sveglia in corrispondenza della wait semantica: riacquisisce il lock ed eventualmente prosegue fino al termine della sezione critica meglio se prima di proseguire ricontrolla la conditional expression importante: se non ci sono thread in attesa, la sveglia va persa E anche possibile svegliare, con apposita routine di broadcast, gruppi di thread in attesa (utile per implementare barriere) 75

76 Esempio condition variables pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER; pthread_cond_t cond = PTHREAD_COND_INITIALIZE; thr1() { pthread_mutex_lock(&mtx); comp1(); event=1; pthread_cond_signal(&cond); pthread_mutex_unlock(&mtx); } thr2() { pthread_mutex_lock(&mtx); while (! event) pthread_cond_wait(&cond, &mtx); comp2(); pthread_mutex_unlock(&mtx); } Thr1 Thr2 evento 76

77 Prod/Cons usando Condition Variables pthread_cond_t cond_queue_empty, cond_queue_full;! pthread_mutex_t task_queue_cond_lock;! int task_available;! /* other data structures here */! main() {! /* declarations and initializations */! task_available = 0;! pthread_init();! }! /* producers wait for empty buffer */! pthread_cond_init(&cond_queue_empty, NULL);! /* consumers wait for full buffer */! pthread_cond_init(&cond_queue_full, NULL);! pthread_mutex_init(&task_queue_cond_lock, NULL);! /* create and join producer and consumer threads */!.....! 77

78 Prod/Cons usando Condition Variables void *producer(void *producer_thread_data) {! while (!done()) {! }! }! create_task();! pthread_mutex_lock(&task_queue_cond_lock);! while (task_available == 1)! pthread_cond_wait(&cond_queue_empty, &task_queue_cond_lock);! insert_into_queue();! task_available = 1;! pthread_cond_signal(&cond_queue_full);! pthread_mutex_unlock(&task_queue_cond_lock);! 78

79 Prod/Cons usando Condition Variables void *consumer(void *consumer_thread_data) {! while (!done()) {! }!!!pthread_mutex_lock(&task_queue_cond_lock);!!!while (task_available == 0)! }!!pthread_cond_wait(&cond_queue_full,!&task_queue_cond_lock);! my_task = extract_from_queue();! task_available = 0;! pthread_cond_signal(&cond_queue_empty);! pthread_mutex_unlock(&task_queue_cond_lock);! process_task(my_task);! 79

80 Meccanismi di sincronizzazione più complessi I pthreads supportano solo un insieme base di operazioni di sincronizzazione Operazioni più complesse e di più alto livello possono essere costruiti usando le operazioni base Esempio Barriere 80

81 Barriere Come in MPI, una barriera blocca un thread fino a che tutti thread partecipanti alla barriera l hanno raggiunta Barriere implementabili tramite un contatore un mutex lock una condition variable Il contatore usato per tener traccia del numero di thread che hanno raggiunto la barriera Se il contatore è minore di N (number of thread), il thread in esecuzione esegue una wait sulla condition variable L ultimo thread che entra nella barriera (e che setta il contatore ad N) sveglia tutti thread in attesa usando una signal broadcast sulla condition variable 81

82 Barriere typedef struct {! pthread_mutex_t count_lock;! pthread_cond_t ok_to_proceed;! int count;! } mylib_barrier_t;! void mylib_init_barrier(mylib_barrier_t *b) {! b -> count = 0;! pthread_mutex_init(&(b -> count_lock), NULL);! pthread_cond_init(&(b -> ok_to_proceed), NULL);! }! 82

83 Barriere void mylib_barrier (mylib_barrier_t *b, int num_threads) {! pthread_mutex_lock(&(b -> count_lock));! b -> count ++;! }! if (b -> count == num_threads) {! b -> count = 0;! pthread_cond_broadcast(&(b -> ok_to_proceed));! }! else! pthread_cond_wait(&(b -> ok_to_proceed, &(b -> count_lock));! pthread_mutex_unlock(&(b -> count_lock));! 83