Small-Scale Shared Address Space Multiprocessor (MIMD) Föreläsning 3: Small-Scale Shared Address Space Multiprocessors & Shared memory programming (OpenMP + POSIX threads) Processorerna kopplade via dynamiskt nätverk/buss till ett gemensamt minne Kommunikation och koordination genom gemensamma variabler i minnet Användaren (kompilatorn) garanterar att data skrivs och läses i rätt ordning (barriärer, semaforer,..) UMA: Alla processorer har samma accesstid till alla minnesmoduler (CC-)NUMA: Processerna har olika accesstid till olika minnesmoduler Datalokalitet (temporal+spatial) viktigt för att erhålla hög prestanda Memory (modules) Memory bus P P P P P Contention Processor-minne kommunikation proportionell mot # proc. Bandbredd ökar proportionell med # processorer Communication Contention Flera processorer vill utnyttja samma länk samtidigt Memory Contention Flera processorer accessar samma minnesmodul samtidigt Serialisering Organisation av minne + nätverk viktiga komponenter för att minska contention Maximalt hundratalet processorer (i praktiken mycket färre), kräver annat än bara en buss Bandbredd till minnet & cacheminnen i multiprocessors Utnyttja lokalitet och inför lokala privata cacheminnen > Minskar accesser till minnet minskar trycket på nätverket Cache-coherence problemet > Flera kopior av ett gemensamt block samtidigt 1
Programmering av SMM Multi och Microtasking Stora likheter med programmering av OS Utförs genom mindre utökningar av befintliga programspråk, OS & bibliotek skapa processer/trådar som exekverar parallellt Olika processer/trådar kan tilldelas olika processorer synkronisera och lås kritiska regioner och data UNIX - Grovkornigt (Multitasking) Lediga processorer tilldelas nya processer kontinuerligt Jobbkö, heavy weight tasks Dynamisk lastbalansering, grovkornig Heterogena tasks gör olika saker Dyrt att skapa i både tid och minne (kopierar allt från föräldrern förutom process ID) POSIX threads - Finkornigt (Microtasking) Light weight processes Parallellitet inom applikation (homogena tasks) En applikation är en serie av fork, join Billigt att skapa i både tid och minne (delar minnesutymme och globala variabler) UNIX Process & shared memory UNIX-process har tre segment: text, exekverbar kod data stack, aktiveringspost + dynamiska data Processer är oberoende och har inga gemensamma adresser fork() - code skapar en exakt kopia av data processen ( pid undantaget) stack l UNIX-process + gemensamt data segment l Vid fork() kopieras allt utom det gemensamma code private data private stack shared data code private data private stack Introducing multiple threads l En tråd är en sekvens av instruktioner som exekveras inom ett program l En normal UNIX-process innehåller en enda tråd En process kan innehålla flera trådar Olika delar av samma kod kan exekveras samtidigt Trådarna bildar en process och delar adressrymden, filer, signalhantering mm. Exempelvis: När en tråd öppnar en fil, är den omedelbart tillgänglig för alla trådar När en tråd skriver till en global variabel, är den läsbar av alla trådar Trådarna har egna IP (instruction pointers) och stackar 2
Exekvering av trådar Master thread Skapa arbetartrådar med phtread_create() Arbetartrådarna startar Arbetartrådarna gör sitt jobb Arbetartrådarna terminerar Join:a arbetarstrådarna med phtread_join() Master thread Koordinering av parallella processer Lock Mekanism för att upprätthålla en policy för hur gemensamma data får läsas/skrivas Determinism Accessordningen är densamma vid varje körning Nondetermenism Accessordningen slumpmässig Indeterminism (inte bra...) Resultatet av nondetermenism vilket medför att olika resultat kan erhållas vid olika körningar. Safe, Live, and Fair Kritisk sektion, Vägkorsning Safe Lock deterministiska resultat (kan leda till unfairness) Unfair Lock ett jobb får vänta i evighet medan andra gör upprepade accesser. Fair Lock alla får accessa i ungefär den ordning de kom + högerregeln (kan leda till deadlocks= alla väntar på grannen till höger ) Live Lock förhindrar deadlocks. Högerregeln Safe but unfair Högerregeln + först till kvarn (FIFO) Safe, fair but not live Högerregeln + först till kvarn + prioritetsordning Safe, fair and live Tvingas vänta i evighet på oändligt många bilar Alla kommer exakt samtidigt och alla tvingas vänta på varandra 1 2 4 3 deadlock 3
Exempel, Spin lock Unsafe Exempel, Spin lock Safe while C do; % spin while C is true C := TRUE; % Lock (C),only one access CR; % Critical section C := FALSE; % unlock(c) l Unsafe båda kommer åt kritisk sektion l Race processerna tävlar om CR Flag[me] := TRUE; while Flag[other] do; CR; Flag[me] := False; % set my flag % Spin % Critical sect. % Clear lock Safe endast en har tillgång till CR; Not live risk för deadlock om alla exekverar 1:a raden samtidigt Exempel på Atomic test and set, Safe och Live Atomic (uninterruptable operation) test and set lock char *lock *lock = UNLOCKED Atomic_test_and_set_lock(lock, LOCKED) % TRUE om lock redan är LOCKED % FALSE om lock ändras från UNLOCKED till LOCKED while Atomic_test_and_set_lock(lock, LOCK); CR; Atomic_test_and_set_lock(LOCK, UNLOCK) % Unlock Locks för samtidig läsning Queue Lock struct q_lock{ int head; int tasks[nprocs]; } lock; void add_to_q(lock, myid) while (head_of_q(lock)!= myid); CR; void remove_from_q(lock, myid); Safe, Live &Fair Kön gör att ingen behöver vänta i evighet på tillträde till CR Nackdel Spinning Hur implementera kön? 4
Multiple Readers Lock SkrivQ Krav Väntrum Flera läsare access till CR samtidigt När skrivare dyker upp tillåts inga fler läsare LäsQ Access Room När läsare i CR är klara har skrivare exklusiv rätt till CR Väntrumsanalogin safe, endast en Writer tillåts träda in i Access Room åt gången fair, när en Writer finns i väntrummet så måste Reader i väntrummet tillåta Writer att gå före, utom då en Writer redan är i Access Room fair, när en Reader finns i väntrummet så måste Writer i väntrummet tillåta Reader att gå före, utom då en Reader redan är i Access Room live, inga deadlocks. Alla som kommit in i väntrummet garanteras tillträde till Access Room Shared memory programming - tools OpenMP POSIX threads OpenMP En portabel fork-join parallell modell för arkitekturer med delat minne Portabel Fortran 77 och C/C++ bindings Många implementationer, alla arbetar på samma sätt (i teorin) Fork-join modell Exekvering startar med en tråd Parallell regioner fork:ar nya trådar vid inträdet Trådarna joinas vid slutet av regionen Delat minne (Nästan allt) minne kan nås av alla trådar OpenMP Två sorters parallellism: Grovkornig (task parallelism) Dela i programmet i segment (trådar) som kan exekveras parallellt Implicit join vid slutet av segmentet, eller explicita synkpunkter (såsom barriärer) Ex: låt två olika trådar anropa varsin subrutin parallellt Finkornig (loopparallellism) Exekvera oberoende iterationer av DO-loopar parallellt Flera val av uppdelning Datamiljöer för bägge sorterna: Delat data Privat data 5
Thread 1 Thread 2 OpenMP i bilder Thread 3 I = 1I = 2I = 3I = 4I = 5I = 6I = 7I = 8 Design of OpenMP A flexible standard, easily implemented across different platforms Kontrollstrukturer Minimalistiska för enkelhet PARALLEL, DO (for), SECTIONS, SINGLE, MASTER Datamiljöer Nya accessmöjligheter för forkade trådar SHARED, PRIVATE, REDUCTION Task parallelism Loop parallelism Design av OpenMP II Synkronisering Enkel implicit synk vid slutet av kontrollstrukturer Explicit synk för mer komplexa mönster: BARRIER, CRITICAL, ATOMIC, ORDERED, FLUSH Lås subrutiner för finkornig kontroll Runtime environment och bibliotek Hanterar inställningar för forkning och för schemaläggning Ex: OMP_GET_THREAD_NUM(), OMP_SET_NUM_THREADS(intexpr) OpenMP-kapacitet kan (i princip) läggas till valfritt språk I verkligheten har OpenMP applicerats till Fortran och C OpenMP är först och främst en mängd direktiv till kompilatorn I Fortran: strukturerade kommentarer som tolkas av kompilatorn C$OMP directive [clause[,],clause[,],..] I C: pragmas som skickar information till kompilatorn: #pragma omp directive [clause[,],clause[,],..] Kontrollstrukturer I PARALLEL / END PARALLEL Fork och join Antalet trådar ändras ej inom regionen? SPMD-exekvering inom regionen SINGLE / END SINGLE (Kort) sekventiell sektion inom parallell region MASTER / END MASTER SINGLE på master-processor (oftast 0) #pragma omp parallel { S1(); #pragma omp single { S2(); } S3(); } PARALLEL S1 S1 S1 S2 S3 S3 S3 END C$OMP PARALLEL CALL S1() C$OMP SINGLE CALL S2() C$OMP END SINGLE CALL S3() C$OMP END PARALLEL 6
Kontrollstrukturer II Kontrollstrukturer III DO / END DO Den klassiska parallella loopen Iterationsrymden delas mellan trådar Statiskt, dynamiskt, guidat Loopindex är normalt privat till trådarna Mer om andra variabler senare C$OMP PARALLEL C$OMP DO DO J = 1, 12 CALL FOO(J) END DO C$OMP END DO C$OMP END PARALLEL PARALLEL END SECTIONS / END SECTIONS Task-parallellism SECTION markerar uppgifter (tasks) Inom en parallell region Nästlad parallellism PARALLEL Kräver en ny parallell region (dvs nytt PARALLEL direktiv) Stöds (tyvärr) inte av alla OpenMP-implementationer END Om det inte stöds, så är den inre PARALLEL:en meningslös PARALLEL END PARALLEL END OpenMP Datamiljöer Delat minne kan vara PRIVATE eller SHARED Deklarera detta i OpenMP-direktiven för parallellism Val SHARED Nås av alla trådar i laget Normalfallet DEFAULT kan ändra detta PRIVATE Varje tråd har en egen kopia Normalt kopieras privata data inte in/ut ur parallella regioner, rörs aldrig av andra trådar FIRSTPRIVATE kopiera det globala värdet till första iterationen LASTPRIVATE - kopierar värdet från sista iterationen Riktlinjer för klassificering av variabler Generellt sätt är stora saker SHARED Huvudmatriserna, de som tar allt utrymme Automatiskt Lokala variabler till subprogram är parallella PRIVATE-variabler Automatiskt Små temporärer är normalt PRIVATE Det krävs oftast en kopia av looptemporärer för varje tråd Automatiskt, för iterationsvariabler 7
OpenMP Datamiljöer II REDUCTION-variabler i DO (for) konstruktioner En lokal fas som följs av en global fas. Initieringen hanteras som förväntat Fortran REDUCTION ops/fcns: +, *, -,.AND.,.OR.,.EQV.,.NEQV., MAX, MIN, IAND, IOR, IEOR C reduction operators: +, *, -, &,, ^, &&, OpenMP Datamiljöer III (Fortran) INTEGER X(3), Y(3), Z C$OMP PARALLEL DO DEFAULT(PRIVATE), SHARED(X), & C$OMP REDUCTION(+:Z) DO K = 1, 3 X(K) = K Y(K) = K * k Z = Z + X(K) * Y(K) END DO C$OMP END PARALLEL DO Shared Memory Thread 0 y 1 z 1 Z 36 X 1 2 3 Thread 1 y 4 z 8 Thread 2 y 9 z 27 OpenMP Synkronisering Implicita barriärer väntar på alla trådar i laget vid slutet av varje konstruktion DO (for), SECTIONS, SINGLE, MASTER NOWAIT vid END kan bortkoppla synkroniseringen Explicita direktiv för finare kontroll BARRIER Väntar på alla trådar i laget CRITICAL (name), END CRITICAL Endast en tråd i taget ATOMIC - Single-statement kritisk sektion för reduktion ORDERED För att ordna (starten av) loopiterationer Och låsrutiner för att ge accesskontroll OpenMP summering Baserat på fork-join-parallellism i delat minne Trådar börjar i början av en parallell region, kommer tillbaka vid slutet Mappar viss hårdvara bra Länkat till traditionella språk För mer information: http://www.openmp.org/ 8
POSIX threads (IEEE standard) Det är billigare att skapa trådar än att forka nya processer Anrop för att skapa och ta bort trådar Anrop för att synkronisera trådar och för att låsa resurser Anrop för att hantera trådschema etc Pthread: Basala rutiner Funktion: pthread_create() int pthread_create(pthread_t * thread, const pthread_attr_t * attr, void * (*start_routine)(void *), void * arg); pthread_create() skapar en ny tråd inom en process. Tråden startar i rutinen start_routine som tar ett startargument arg. attr specar attribut, eller default-attribut om NULL (se Lab 1). Om pthread_create()-rutinen lyckas, returneras 0 och den nya trådens ID läggs i thread, annars returneras en felkod. Att avsluta en tråd Funktion: pthread_exit() void pthread_exit(void * status); Avslutar den för närvarande körande tråden och gör status tillgängligt till den tråd som joinar, pthread_join(), med den terminerande tråden. Ett annat sätt att avsluta: return. Threads som inte joinas kallas detached. Bör användas om man inte explicit behöver joina dem: mer effektivt! Hello World... or World Hello? void *print_message_function( void *ptr ); main() { pthread_t thread1, thread2; char *message1 = "Hello, *message2 = "World"; void *status1, *status2; pthread_create(&thread1, NULL, print_message_function, (void*) message1); pthread_create(&thread2, NULL, print_message_function, (void*) message2); pthread_join(thread1, &status1); pthread_join(thread2, &status2); return 0; } void *print_message_function( void *ptr ) { char *message; message = (char *) ptr; printf("%s ", message); } 9
Joining threads Funktion: pthread_join() int pthread_join(pthread_t thread, void ** status); Om måltråden thread ej är detached ( avkopplad ) så väntar pthread_join() på att måltråden thread ska avslutas. Identifying and comparing threads Funktion: pthread_self() and pthread_equal() pthread_t pthread_self(void); returnerar id för den anropande tråden. int pthread_equal(pthread_t thread_1, pthread_t thread_2); jämför id för thread_1 and thread_2 och returnerar nollskilt värde om id:na representerar samma tråd Pthread: Synkroniseringsroutiner Funktion: pthread_mutex_init() int pthread_mutex_init(pthread_mutex_t * mutex, const pthread_mutex_attr *attr); Skapar en ny mutex (mutually exclusive lock), där attr specificerar attribut, eller defaultattribut om attr är NULL. int pthread_mutex_destroy(pthread_mutex_t * mutex); int pthread_mutex_lock(pthread_mutex_t * mutex); Låser mutexen mutex. Om mutex redan är låst, blockas den anropande tråden till mutex blir tillgänglig. int pthread_mutex_trylock(pthread_mutex_t * mutex); critical section (one thread only at one time) int pthread_mutex_unlock(pthread_mutex_t * mutex); Condition variables Tillståndsvariabler associeras med en specifik mutex kan låsa en tråd tills en signal ges från annan tråd Funktion: pthread_cond_init(). Skapar en ny tillståndsvariabel: int pthread_cond_init(pthread_cond_t * cond, const pthread_cond_attr *attr); int pthread_cond_signal(phtread_cond_t * cond ); int pthread_cond_destroy(pthread_cond_t * cond); int pthread_cond_wait(pthread_cond_t * cond, pthread_mutex_t * mutex); 10
Pthreads - allmänt #include <pthread.h> först i programmet Länka med lpthread På chips: Använd kompilatorerna xlc_r (cc_r) / xlf_r Kontrollera alltid felkoder! Mer info: Getting Started With POSIX Threads, man-sidor Typiska prestandaproblem Problem: Otillräcklig parallellism Symptom: flat scaling Åtgärd: parallellisera andra sektioner / nästlad parallellism Problem: För dyr synkronisering Symptom: kostnaden ökar med fler processorer Åtgärd: NOWAIT / kombinera konstruktioner / parallellisera på högre nivå / bättre synkroniseringscheman Problem: Dåligt cacheanvändande Symptom: dålig enprocessor-prestanda Åtgärd: justera loopar / ändra datastrukturer och/eller accesser till dessa Pros n cons Portabilitet OpenMP: Bra C/FORTRAN-kompilatorer Pthreads: bibliotek. Nu även med FORTRAN bindings Funktionalitet OpenMP: Perfekt för HPC-applikationer! Pthreads: Lite mer generellt, men viss funktionalitet saknas (exempel: barriärer) Prestanda OpenMP är bättre än pthreads för finkorniga problem. Skapar dessutom inte parallellism i onödan Nyare versioner av pthreads är även de effektiva Standard OpenMP är relativt nytt som standard Pthreads är stabilt. Cache-aspekter 11
Varför cache:ar? Cache Coherence Problemet Cache-minnen tjänar till att: Öka bandbredden mot minnet, samtidigt minska belastningen på minnesbuss. Korta latensen (fördröjning) Memory Bra för både gemensamt och privat data. Men hur hålls datat överensstämmande? (consistent) Memory bus $ $ $ $ $ P P P P P Delning kan resultera i flera kopior av samma, gemensamma, block i ett eller flera cacheminnen samtidigt. För att ge en följdriktig vy av minnet, måste kopiorna överensstämma. Existerar olika lösningar från Hårdvara Mjukvara Cache Coherence Problemet Thanks to Erik Hagersten, TDB in Uppsala, for the pictures Följdriktighet vadå? Informellt En read måste returnera senaste write För strikt, och för svårt att implementera Bättre En write måste, till slut, kunna ses av en read Alla writes måste ses i ordning ( serialisering ) Två regler 1. Om P1 skriver x och P2 läser x, kommer P1s write att ses om read och write är tillräckligt långt ifrån varandra 2. Writes till en adress är serialiserade. l Senaste writen syns, annars kan man se gamla värden efter nya 12
Hårdvarubaserade protokoll Garantera minnesföljdriktighet utan mjukvarustyrning Snoopy cache protocol ( snooping ) Directory schemes Cache-coherent network architecture data delas in i block av samma storlek blocken är den enhet som skickas mellan minne och cache godtyckligt många kopior av ett block tillåts existera samtidigt Uppdateringar inom blocken hålls synliga för alla Cache coherence-policies Write Invalidate: läsning utföres lokalt om block existerar vid uppdatering ogiltigförklaras (invalidate) alla andra kopior ytterligare uppdateringar kan göras ty alla andra kopior ogiltiga Write Update: uppdaterar alla kopior istället för ogiltigförklarar (broadcast) Consistency Commands Ett enkelt c.c.-protokoll invalidation & update commands Buss-baserade arkitekturer Broadcasta alla consistency commands alla cache måste processa alla meddelanden Snokar i nätverket "snoopy cache protocol" Switching networks-baserade arkitekturer Skickar consistency commands endast till de som har en kopia kräver book-keeping, directory schemes Buss-kommandon: 1. A) Skicka förfrågan till ägaren att returnera data till minnet. (BRB) B) Läs data från minnet. 2. Bus Invalidate (BInv) 13
False Sharing Olika delar av samma block (cache line) används av olika processorer Om en processor skriver till en del av blocket, så måste kopior av det (kompletta blocket) antingen uppdateras eller invalideras. Detta trots att data egentligen inte delas. Repetitionsuppgifter Beskriv enkelt uppbyggnaden av en parallellmaskin med gemensamt minne! Vad är cache conherency problemet och hur löser man det? Vad är fork-join? Tentauppgift 040116, 4a m, n Frobeniusnormen av en m x n matris A definieras A = a F i, j i= 1, j= 1 Implementera en subrutin som beräknar Frobeniusnormen av A parallellt på en maskin med gemensamt minne m h a OpenMP eller pthreads! 2 14