Parallelle systemen

overzicht inleiding: wat is een parallel systeem, nood, toepassingen parallelle systemen: architecturen classificatie van parallelle architecturen parallelle architecturen die men op de markt aantreft supercomputers (= vector-computers) multiprocessoren multicomputers geavanceerde multiprocessoren: multi-threaded-architecturen en NUMA-architecturen parallelle systemen: software granulariteit performantie

Inleiding ideen om hier uit te breiden, na overlopen (niet lectuur) van H8 uit CAQA. toevoegen aan multiprocessoren: het cache coherence probleem (pp 655-657) enkele oplossingen (zie pp 657-660) toevoegen aan multicomputers mogelijkeheid tot DSM (pp 677 en volgenden) toevoegen bij software of bij multiprocessoren het probleem van synchronisatie en oplossingen (pp 694 en volgenden) toevoegen bij performantie: stukje uit Hardware Software Interface, H9, pp 603-606

Wat is een parallel systeem? een verzameling van processing elementen die samenwerken om een groot probleem snel op te lossen belangrijke punten: Resource allocatie: hoeveel elementen? hoe krachtig zijn de elementen? hoeveel geheugen ? Data toegang, communicatie en synchronisatie hoe communiceren en synchroniseren de elementen? hoe worden gegevens doorgegeven ? welke abstracties en primitieven worden gebruikt ? Performantie en schaalbaarheid hoe vertaalt zich dat in performantie ? is het schaleerbaar ?

Inevitability of Parallel Computing Applicatievereisten: onverzadigbare nood aan rekenkracht Scientific computing: CFD, biologie, scheikunde, natuurkunde, ... General-purpose computing: video, graphics, CAD, databases, TP... technologietendensen aantal transistoren op een chip stijgt snel kloksnelheid stijgt minder snel architectuurtendensen Instruction-level parallelism is waardevol maar beperkt grover parallellisme, zoals in MPs, heeft de meeste toekomst huidige tendensen: microprocessoren van vandaag ondersteunen multiprocessoren Servers en werkstations worden MP: Sun, SGI, DEC, COMPAQ! microprocessoren van (over)morgen zijn multiprocessoren

Scientific Computing Demand

Engineering Computing Demand grote parallelle machines steunpilaren in vele industries Petroleum (reservoir analysis) Automotive (crash simulation, combustion efficiency) Luchtvaart (airflow analysis, motor efficiency, structural mechanics, electromagnetism) Computer-aided design Farmaceutische industrie (molecular modeling) visualisatie in al de domeinen hier boven vernoemd entertainment (films zoals Toy Story) architectuur (walk-throughs en weergave) Financial modeling (yield and derivative analysis) enz.

Applications: Speech and Image Processing Also CAD, Databases, . . . 100 processors gets you 10 years, 1000 gets you 20 !

Commercial Computing steunt ook op parallellisme voor high end individuele systemen niet zo groot maar gebruikt op grotere schaal Databases, online-transaction processing, decision support, data mining, data warehousing ... TPC benchmarks (TPC-C order entry, TPC-D decision support) systemen kunnen groeien met grootte van bedrijf doorvoer wordt gebruikt om performantie te meten (transacties per minuut of tpm)

TPC-C resultaten (maart 1996) Parallellisme is overal aanwezig vooral klein tot middelgrootte schaal van parallellisme

samenvatting van applicatietendensen wetenschappelijk en industriële computing is gemigreerd naar parallel computing in commercial computing is er grote vooruitgang Database en transacties, en ook financies meestal kleinere schaal vraag voor betere throughput op sequentiële workloads grootste gebruik van kleine multiprocessoren applicatienoden bestaan en zullen groter worden

Technologietendensen The natural building block for multiprocessors is now also the fastest!

Phases in VLSI Generation How good is instruction-level parallelism? Thread-level needed in microprocessors ?

Classificatie van parallelle architecturen ideen om hier uit te breiden, na overlopen (niet lectuur) van H8 uit CAQA. toevoegen aan multiprocessoren: het cache coherence probleem (pp 655-657) enkele oplossingen (zie pp 657-660) toevoegen aan multicomputers mogelijkeheid tot DSM (pp 677 en volgenden) toevoegen bij software of bij multiprocessoren het probleem van synchronisatie en oplossingen (pp 694 en volgenden) toevoegen bij performantie: stukje uit Hardware Software Interface, H9, pp 603-606

waarom een classificatie ? een classificatie helpt begrijpen wat er reeds verwezenlijkt is een classificatie toont eventueel nieuwe mogelijkheden een classificatie helpt bij het formuleren van modellen van eigenschappen bv. het modelleren van performantie: een classificatie kan ons helpen begrijpen waarom bepaalde architecturen performanter zijn dan andere

we behandelen hier 4 classificaties: classificatie van Flynn (1972): meest gekende classificatie, onvoldoende om alle huidige architecturen goed in kaart te brengen classificatie van Skillicorn (1988): uitbreiding van de classificatie van Flynn classificatie van Feng: zegt iets over de graad van parallellisme dat bereikt is classificatie naar sturing van bewerkingen: zegt iets over architecturen die helemaal afstappen van het Von Neumann model

Classificatie van Flynn deze classificatie steunt erop dat parallellisme kan ingevoerd worden zowel op het niveau van de instructie-stroom als van de gegevensstroom zo krijgt men de volgende architecturen: SISD: single instruction stream - single data stream de klassieke monoprocessor SIMD: single instruction stream - multiple data stream de array-processor (\(!= vector-processor !!!) MISD: multiple instruction stream - single data stream komt niet voor MIMD: multiple instruction stream - multiple data stream de multiprocessor en de multicomputer zie figuren

typische karakteristieken van SIMD en MIMD SIMD MIMD klok synchroon asynchroon toepassingen numeriek formeel parallellisme impliciet expliciet controle gecentraliseerd gedecentraliseerd relatie meester/slaaf klant/server

Classificatie van Skillicorn deze classificatie brengt niet alleen in kaart het aantal instructie-processoren en data-processoren maar bekijkt ook de verbindingen tussen: de instructie- en de data-processoren de instructie-processoren en de geheugenmodules met instructies de data-processoren en de geheugenmodules met data de data-processoren onderling

Classificatie van Skillicorn (vervolg) deze verbindingen kunnen de volgende vormen aannemen: geen: er zijn geen verbindingen tussen eenheden van de ene soort en eenheden van de andere soort 1-1 of n-n: één eenheid van de ene soort is verbonden met één eenheid van de andere soort 1-n: de enige eenheid van de ene soort is verbonden met elke eenheid van de andere soort nxn: elke eenheid van de ene soort is verbonden met elke eenheid van de andere soort zie figuren

Classificatie van Feng deze classificatie brengt in kaart de maximale graad van parallellisme die bereikt wordt in computer-architecturen: dit wordt gedefinieerd als het aantal bits dat tegelijk behandeld wordt dit wordt berekend door middel van twee assen: op de horizontale as wordt de woordlengte van een architectuur uitgezet de verticale as geeft aan hoeveel bits van een zelfde positie in een woord in parallel behandeld worden dit parallellisme kan bereikt worden zowel via pipelining als door middel van meerdere data-processoren zie figuur

Classificatie naar sturing van bewerkingen deze classificatie bekijkt hoe bepaald wordt welke databewerkingen uitgevoerd worden Von Neumann architecturen: een programma, dat duidelijk de volgorde van de bewerkingen beschrijft, bepaalt de databewerkingen in de architectuur komt hier altijd een programma-teller voor

Classificatie naar sturing van bewerkingen (vervolg) data-flow architecturen: die bewerkingen waarvoor de input-gegevens reeds beschikbaar zijn (van de invoer of van eerdere berekeningen) kunnen uitgevoerd worden op elk moment zijn er meestal meerdere bewerkingen die uitgevoerd kunnen worden in parallel het zijn de gegevens die de bewerkingen sturen aspecten van data-flow komen voor in moderne monoprocessoren (zie hoofdstuk 4: dynamisch schedulen van instructies)

Dataflow architecturen voorstelling van programma als een grafe van afhankelijkheden Logische processor in elk knooppunt, wordt geactiveerd door beschikbaarheid van operanden Message (tokens) met tag van volgende instructie wordt verzonden naar volgende processor Tag wordt vergeleken met andere in matching store; een match vuurt een uitvoering

Dataflow Architectures

Classificatie naar sturing van bewerkingen (vervolg) reductie architecturen: die bewerkingen die nodig zijn om het resultaat te berekenen zullen uitgevoerd worden op elk moment zijn er zo meestal meerdere bewerkingen in deze architectuur stuurt het gewenste resultaat de bewerkingen de beschrijving is zeer functioneel

Types parallelle architecturen die men op de markt treft klassieke modellen

Supercomputers of vectorcomputers VOORZICHTIG!!! een vectorcomputer != een array-computer zeer complexe machines, met een onregelmatige structuur proberen verhoogd parallellisme te bereiken door het combineren van meerdere methodes: vectorregisters en vectorinstructies meerdere functionele eenheden (die elk niet alle instructies kunnen uitvoeren) met een zware pipeline door hun concentratie op vector-operaties lijken ze voor een gebruiker erg op een array-processor

Supercomputers of vectorcomputers (vervolg) vector processing: basis principes vervang DO 1 I=1,N 1 C(I) = A(I) + B(I) (N scalaire optellingen) door C(1:N) = A(1:N) + B(1:N) (1 vector optelling)

Supercomputers of vectorcomputers (vervolg) uitvoeringstijd: eenvoudige kijk op de zaak Ts = N * t(+) Tv = N * (t(+)/r) + setup (voor r stages) ook rekening houden met aantal in te lezen instructies aantal te decoderen instructies overhead van het beheren van de lus (nog eens N integer optellingen, N vergelijkingen en N sprongen) inlezen van 1 vector gaat veel sneller dan N aparte getallen inlezen (er zijn vector-registers)

Supercomputers of vectorcomputers (vervolg) soorten operaties: scalair (real, int, ...) rij van N scalairen unaire operaties: f1 V -> V f2 V -> S binaire operaties: f3 V x V -> V f4 V x S -> V

Supercomputers of vectorcomputers (vervolg) velden van een vector-operatie opcode voor operanden en resultaat: vector register of basis adres in het geheugen en increment vector lengte

Supercomputers of vectorcomputers (vervolg) chaining doorsturen van een resultaat van een vector-operatie naar een andere vector-pipeline die op het resultaat een tweede bewerking uitvoert voordeel: tweede maal is geen opstart tijd nodig; verder een store en load minder het parallellisme wordt meestal door de compiler toegevoegd (voor de vector-operaties) parallellisme wordt ook dynamisch toegevoegd door schedulen van instructies op verschillende functionele eenheden het gebruikte parallellisme is fijn vb. : Cray deze ideeën worden nu gebruikt in monoprocessoren

Raw Uniprocessor Performance: LINPACK

Multiprocessoren multiprocessoren = MIMD-machine met gedeeld geheugen homogeen van structuur symmetrisch van structuur (alle knooppunten hebben gelijkaardige rol) maken gebruik van standaard componenten zijn daarom ook veel goedkoper dan een supercomputer granulariteit van parallellisme : middelmatig (niet ontzettend fijn, ook niet grof) M1 ... Mn M0 interconnectienetwerk P0 ... Pn P1

Multiprocessoren (vervolg) lineaire versnelling wordt nooit bereikt extra kost door synchronisatie extra kost door niet perfect gespreide belasting niet elk programma is 100% parallelliseerbaar de architectuur kan niet zomaar uitgebreid worden naar meer processoren: de bereikbaarheid van het geheugen door alle processoren (via een bus bv.) is altijd een bottleneck daarom NUMA -architecturen: zie verder een lokale cache wordt soms voorzien om het bottleneck-probleem gedeeltelijk te verhelpen, maar de caches moeten consistent gehouden worden

voor- en nadelen van multiprocessoren voordelen geen nieuw programmeringsmodel: gemakkelijk efficiënte communicatie: kopiëren niet nodig nadelen synchronisatie moeilijker dan via boodschappen is niet uitbreidbaar op grote schaal door onderlinge strijd om het geheugen (memory contention)

Architectural Trends: Bus-based MPs microcomputer op een chip maakt het gemakkelijk om vele te verbinden met gedeeld geheugen domineert de server en de ondernemingsmarkt, er is een tendens naar omlaag, naar de desktop computers (krachtige werkstations) verzadiging van bus drijft deze technologie vooruit orde van grote van bus-gebaseerde systemen van desktop tot grote servers: zie volgende twee slides No. of processors in fully configured commercial shared-memory systems

Architectural Trends: Bus-based MPs No. of processors in fully configured commercial shared-memory systems

Bus Bandwidth

Multicomputers multicomputers = MIMD-machine met gespreid geheugen zijn ook homogeen van structuur interconnectienetwerk M0 P0 M1 P1 Mn Pn ...

Multicomputers (vervolg) zijn meestal niet symmetrisch, doordat de interconnectie van de processoren meestal niet volledig is (niet alle processoren zijn met alle processoren verbonden) processoren kunnen dus "ver" of "dichtbij" zijn, men spreekt ook eventueel van "buren" de communicatie-kost is dan niet gelijk tussen elk willekeurig paar knooppunten multicomputers maken gebruik van standaard componenten ze zijn daarom ook veel goedkoper dan een supercomputer granulariteit van parallellisme: grof

Multicomputers (vervolg) spreiding van belasting is hier moeilijker dan bij multiprocessoren omdat de code en de hele adresruimten van processen lokaal zijn de architectuur (afhankelijk van de interconnecties) kan gemakkelijk uitgebreid worden tot zeer veel knooppunten (MPP) grote machines bieden vaak "space-sharing": meerdere toepassingen kunnen in parallel lopen; elke toepassing krijgt een fysisch afgebakend deel van de machine door ‘distributed shared memory’ (DSM) kan men op multicomputer werken zoals op multiprocessoren

voor- en nadelen van multicomputers voordelen processoren werken meestal met lokaal geheugen netwerk minder belast architectuur uitbreidbaar op grote schaal (MPP) geen ingewikkelde synchronisatie nodig nadelen belastingsspreiding is absoluut noodzakelijk communicatie met boodschappen: deadlock-gevaar

Raw Parallel Performance: LINPACK Even vector Crays became parallel: X-MP (2-4) Y-MP (8), C-90 (16), T94 (32) Since 1993, Cray produces MPPs too (T3D, T3E)

500 Fastest Computers Number of systems u n s 11/93 11/94 11/95 11/96 50 100 150 200 250 300 350 PVP MPP SMP 319 106 284 239 63 187 313 198 110 73

Types parallelle architecturen die men op de markt treft geavanceerde modellen

uitdaging uitdaging: verhogen uitbreidbaarheid multiprocessoren aangepast interconnectie netwerk lokale caches voorzien data in cache aanwezig: geen beroep op netwerk klassiek gebruik van lokaliteitprincipe probleem indien zelfde data in meerdere caches aanwezig is: cachecoherentie-probleem fysische implementatie zoals multicomputers ‘virtueel gedeeld geheugen’ of ‘gedistribueerd gedeeld geheugen’ (DSM) lokale geheugens zijn componenten van globale adresruimte

classificatie van DSM NUMA CC-NUMA COMA Non-uniform Memory Access machines Cache-Coherent Non-Uniform Memory Access machines Cache-Only Memory Access machines NUMA CC-NUMA COMA

NUMA COMA CC-NUMA ... ... ... M1 P1 M0 P0 Mn Pn interconnectienetwerk

problemen bij uitbreidbare computers tolereren en verbergen van wachttijd (a) bij het laden van niet-lokale gegevens (b) bij het synchroniseren tussen processen mogelijke oplossingen voor (a) caches prefetching mogelijke oplossingen voor (a) en (b) gebruik van threads en zeer snelle contextwisselingen

Multi-Threaded Architecturen basisprincipes gebaseerd op uitvoeren van vele threads per node contextswitch is logisch gelijk aan de klassieke contextswitch moet veel sneller zijn dan wachten op niet-lokale gegevens synchronisatie moet snel herkend worden threads hebben hele fijne granulariteit contextswitch is hardware ondersteund

multi-threaded architecturen alternatieven voor verwezenlijking bewerkingsmodel volledig von Neuman (control flow) hybride von Neuman / dataflow granulariteit heel fijn: meerdere threads delen de pipeline leunt meer aan bij dataflow minder fijn: slechts 1 thread voert uit leunt meer aan bij control flow

multi-threaded architecturen alternatieven voor verwezenlijking (vervolg) geheugenorganisatie gedeeld, NUMA, CC-NUMA aantal threads per processor klein (4-10), middelmatig (10-100), groot (>100) voorbeelden HEP, Tera, MIT Alewife (CC-NUMA): control flow *T, SAM, MIT Hybrid machine, EM-4: dataflow

Multicomputer MPP kenmerken processoren enkel toegang tot lokaal geheugen communicatie met boodschappen uitdaging tov communicatie: goede opsplitsing van probleem in processen goede verdeling van processen over knopen NP-compleet belastingspreiding is noodzakelijk machines populair voor problemen die veel parallellisme bevatten (MPP)

Multicomputer MPP alternatieven voor verwezenlijking interconnectienetwerk topologie, switching techniek, routeringsprotocol meerdere generaties knoop-organisatie processor + comm. co-processor + router type processoren: bestaande of speciaal ontworpen processoren gewone of vectorprocessoren

Multicomputer MPP alternatieven voor verwezenlijking (vervolg) bewerkingsmodel conventioneel + communicatiebibliotheken CSP dataflow voorbeelden iPSC/1, iPSC/2, Ametek, Intel Paragon, IBM SP2, Parsytec GC/PowerPlus, Transtech Paramid nCUBE, Meiko CS-2 Transputer, Parsys Supernode, Parsytec Gigacube Caltech Mosaic 2, J-Machine

MIMD met gedeeld geheugen alternatieven voor verwezenlijking interconnecties cache coherence snoopy directory-schema hiërarchisch software-gebaseerd synchronisatie consistentiemodel UMA, NUMA, CC-NUMA en COMA

alternatieven voor verwezenlijking fysische organisatie van logisch gedeeld geheugen fysisch gedeeld geheugen: UMA virtueel of gedistribueerd gedeeld geheugen (DSM): NUMA, CC-NUMA, COMA interconnectienetwerk gedeeld medium (single bus, multiple bus) switching netwerken (crossbar, multistage) cache-coherence protocol hardware-gebaseerd software-gebaseerd

interconnectienetwerken: bussen enkelvoudige bus elke knoop en elke geheugenmodule aan bus broadcast is eenvoudig eenvoudig, goedgekend, goedkoop gevaar voor verzadiging: daarom niet geschikt voor groot systeem meervoudige bus: 1-dimensionaal meerdere bussen in parallel elke knoop en geheugenmodule aan elke bus

interconnectienetwerken: bussen meervoudige bus: 2- of 3-dimensionaal bussen zijn georganiseerd in een rooster verschillende manieren om knopen en geheugenmodules aan bussen te hangen hiërarchisch systeem meerdere enkelvoudige bus-systemen (clusters) clusters verbonden door enkelvoudige bus recursief zijn meerdere niveaus mogelijk goedkoop

Voorbeeld van hiërarchisch systeem Sequent NUMA-Q 2000

interconnectienetwerken: switching crossbar gelijktijdige toegang mogelijk van elke processor met een geheugenmodule (hoge bandbreedte) gebruikt zeer vele switchen, is dus zeer duur multistage compromis tussen enkelvoudige bus en crossbar variaties in kost, complexiteit, bandbreedte zeer veel verschillende soorten

Cache coherence oorsprong van probleem delen van wijzigbare gegevens (belangrijkst) procesmigratie in- en uitvoer verschillende hardware protocols afhankelijk van memory update policy cache coherence policy interconnectieschema

cache coherence: algemeen memory update policy write-through policy (gulzig) bij write op cache wordt geheugen aangepast gebruikt veel bandbreedte erg nadelig bij geheugen dat niet gedeeld wordt write-back policy (lui) geheugenaanpassing later andere aanvraag voor zelfde blok: blok moet uit aangepaste cache komen maakt cache controllers ingewikkelder

cache coherence: algemeen cache coherence policy write-update policy (gulzig) bij write worden alle copies aangepast gebruikt veel bandbreedte write-invalidate policy (lui) bij write worden de andere copies ongeldig

cache coherence: algemeen interconnectieschema broadcast mogelijk (enkelvoudige bus) snoopy cache protocol hiërarchisch bussysteem hiërarchisch cache coherence protocol multistage directory-schema’s volledige tabellen (full-map) beperkte tabellen (limited directories) gelinkte tabellen (chained directories)

snoopy cache protocol basisprincipes (voor write-update) mogelijke toestanden per blok in een cache exclusief en geldig gedeeld exclusief en vuil alle consistentiecommando’s worden ge-broadcast Read-Blk, Write-Blk, Update-Blk iedere processor ziet deze (snoops) eindige toestandsmachine beschrijft veranderingen in toestand (zie volgende slide)

snoopy cache protocol (vervolg) P-Read P-Read P-Read P-Write P-Read P-Write exclusief geldig gedeeld Read-Blk/Write-Blk Read-Blk Write-Blk Update-Blk P-Write P-Read, P-Write: opdrachten gegeven vanuit eigen processor Read-Blk, Write-Blk, Update-Blk: consistentiecommando’s die op de bus verschijnen Read-Blk/Write-Blk exclusief vuil P-Read P-Write

directory schema’s basisprincipes consistentie commando’s enkel gestuurd naar caches waar een copie van blok zit bijhouden per blok hoofdgeheugen waar gecached is afhankelijk van organisatie van directory volledige tabel beperkte tabel gelinkte tabel maakt een verschil in geheugen nodig om directory bij het houden aantal consistentie commando’s nodig

directory schema’s (vervolg) volledige tabel directory wordt bijgehouden in gedeeld geheugen per blok: boolean per cache (blok in cache of niet) in elke cache: twee bits per blok geldig write-toelating beperkte tabel gebruikt minder geheugen logisch gezien gelijkaardig aan volledige tabel ipv bits: volledige pointers maximum aantal pointers voorzien

directory schema’s (vervolg) gelinkte tabel compromis tussen vorige twee: minder geheugen als volledige tabel heeft geen last als teveel pointers pointer maakt deel uit van blok in cache voorbeeld uitwerking: Scalable Coherent Interface (SCI) IEEE standard 1992 meer dan 30 verschillende toestanden !

hiërarchisch CC-protocol bij hiërarchische meervoudige bussen basisprincipe: elke processor in een cluster heeft een cache elke cluster heeft een supercache een blok dat in minstens 1 cache van een cluster zit moet ook in de supercache zitten op elk niveau wordt een variante van het snoopy protocol gebruikt

hiërarchisch CC-protocol (vervolg) Main Memory C20 C21 C22 C0 P0 C1 P1 C2 P2 C3 P3 C4 P4 C5 P5 C7 P7 C6 P6 C9 P8

software-gebaseerde protocols geen hardware-ondersteuning nodig wel compiler-ondersteuning nodig classificatie van variabelen in 4 klassen read-only read-only voor meerdere processen maar write-only voor slechts 1 proces read-write voor slechts 1 proces read-write voor meerdere processen verdeling in klassen per programmaonderdeel bv per lus na elke lus wordt cache ongeldig (kan selectief)

synchronisatie hardware-ondersteuning voor synchronisatie-routines probleem: synchronisatie komt veel voor synchronisatie op een lock-variabele door meerdere processen: hot-spot klassieke test&set zeer inefficiënt while (exchange(lock, CLOSED) == CLOSED);

synchronisatie (vervolg) oplossingen bij bus-gebaseerde systemen snooping lock while (exchange(lock, CLOSED) == CLOSED) while (*lock == CLOSED) test-and-test&set volgorde omdraaien: eerst lezen eventueel een random delay toevoegen queue lock: een lijst van wachtenden slechts 1 wordt verwittigd als lock vrij komt

synchronisatie (vervolg) oplossingen bij grote systemen fetch&add (x, a) telt a bij x op en geeft oude waarde van x terug optelling gebeurt in geheugenmodule eventueel zelfs in switchen van multistage lijst-gebaseerde lock

consistentiemodellen consistentiemodel: interface programmeur/systeem sequentiële consistentie meest intuïtieve niet evident in NUMA-machines niet-atomaire geheugentoegangen invalideren van caches niet overal tegelijk laat een aantal optimisaties niet toe (bv prefetching, later wegschrijven) zwakkere vormen van consistentie

consistentiemodellen (vervolg) zwakkere vormen van consistentie uitgangspunt sequentiële consistentie niet echt nodig meeste programma’s synchroniseren expliciet meerdere modellen weak consistency model datatoegang tussen synchronisatie mag uit volgorde gebeuren release consistency model laat nog meer overlapping toe

consistentiemodellen (vervolg) implementatie van consistentiemodellen gebruik van ‘hekken’ (fences) in verschillende vormen hek zorgt ervoor dat alle writes werkelijk overal gebeurt zijn werkt met gebruik van tellers SCI ondersteunt zowel weak consistency als release consistency

UMA -systemen zeer geschikt voor het bouwen van kleine performante multiprocessoren met enkelvoudige bus kostprijs is heel redelijk niet uitbreidbaar tot grote aantallen voorbeelden Encore Multimax, SGI Challenge

-systemen NUMA goed uitbreidbaar kwetsbaar tov plaatsing van gegevens geen caches ondersteunen vaak zowel programmeren met gedeeld geheugen communicatie via boodschappen voorbeelden BBN TC2000, IBM RP3, Cray T3D

-systemen CC-NUMA goed uitbreidbaar momenteel interessantste architectuur voor grote algemeen bruikbare parallelle systemen verschillen in interconnectienetwerk cachecoherentieprotocol voorbeelden Dash, Flash, Convex Exemplar, Sequent Numa-Q 2000, Silicon Graphics Origin2000

CC-NUMA Quad = 4 Pentium Pro 180 Mhz, 512KB L2 512MB-4GB memory 7 PCI I/O slots (133MB/s) IQ-link= 1 Gbyte/sec ring, 32MB-128MB Fast Cache

CC-NUMA Zes adres-bits begrenzen aantal Quads op 63 (252 processoren) 0-7 I/O Adapters 0-7 I/O Adapters 0-7 I/O Adapters 500 MB/s 500 MB/s 500 MB/s 1-4 GB Mem 1-4 GB Mem 1-4 GB Mem IQ-Link IQ-Link IQ-Link 1GB/s link 1GB/s link 1GB/s link Zes adres-bits begrenzen aantal Quads op 63 (252 processoren) IQ-Link is geen bus. Over de ring kunnen gelijktijdig meerdere transfers plaatsvinden

CC-NUMA IQ-LINK Data Pump CPU CPU CPU CPU EISA Bus Memory PCI Bridge P6 Bus EISA Bus Memory PCI Bridge 4 x SMP System Bus MDC EISA OBIC Memory Directory PCI Bus PCI Bus Remote Cache and Cache State/Tags PCI I/O PCI/EISA Bridge PCI I/O PCI I/O SCLIC PCI I/O PCI I/O Data Pump PCI I/O PCI I/O IQ-LINK

-systemen COMA goed uitbreidbaar allocatie van gegevens is statisch niet nodig gebeurt dynamisch, vraag-gestuurd analoge cachecoherentieprotocols als bij CC-NUMA voorbeelden Data Diffusion Machine, KSR1

trends naar de toekomst toe convergentie van de drie trends binnen MIMD multi-threaded architecturen systemen met gedistribueerd geheugen systemen met gedeeld geheugen

Applicatiesoftware voor parallelle systemen

typische problemen simuleren van de stromingen in de oceanen regelmatige structuur, scientific computing simuleren van de evolutie van de sterren-galaxies onregelmatige structuur, scientific computing weergeven van scènes door middel van ray tracing onregelmatige structuur, computer graphics data mining onregelmatige structuur, information processing wordt hier niet besproken

simulatie van oceaanstromen (a) doorsneden (b) ruimtelijke discretisatie van een doorsnede modelleren als twee-dimensionale roosters discretiseren in ruimte en in tijd hoe fijner ruimtelijke en temporele resolutie: hoe accurater veel verschillende berekeningen per tijdsstap het opzetten en het oplossen van vergelijkingen concurrency over en in de rooster berekeningen

simulatie van galaxy-evolutie simulatie van de interacties tussen miljoenen sterren die evolueren het berekenen van de krachten is duur O(n2) met brute kracht aanpak hiërarchische methode gebaseerd op wet van krachten: G m1m2 r2 veel tijdsstappen, veel concurrency over de sterren bij elke tijdsstap

weergave van scènes door Ray Tracing stuur stralen in de scène door de pixels in het beeldvlak volg hun paden de stralen weerkaatsen als ze objecten tegenkomen ze genereren nieuwe stralen: een stralenboom per invoerstraal dit resulteert in kleur en “opacity” voor dat pixel er is parallellisme tussen de stralen al deze voorbeelden hebben overvloedige concurrency

creëren van een parallel programma veronderstelling: een sequentieel algoritme is gegeven soms is een erg verschillend algoritme nodig, hier niet ter sprake creëren van een parallel programma bestaat uit: identificatie van het werk dat in parallel kan gebeuren partitionering van werk en van gegevens over processen beheer van toegang tot gegevens, communicatie en synchronisatie Note: werk = zowel berekeningen als toegang tot gegevens als I/O hoofddoel: Speedup, kleine programmeringsinspanning, laag middelengebruik Speedup (p) = voor een vast probleem: Speedup (p) = Performance(p) Performance(1) Time(1) Time(p)

stappen bij creëren van // programma 4 stappen: decompositie, toekenning, orkestratie, mapping door programmeur of door systeemsoftware (compiler, runtime, ...) issues zijn dezelfde, dus veronderstellen we door de programmeur

enkele belangrijke concepten taak: arbitrair deel van het werk van een parallelle berekening taak sequentieel uitgevoerd: enkel concurrency tussen taken vb: cel in Barnes-Hut, straal of groep van stralen bij ray tracing taken kunnen een fijne of een grovere granulariteit hebben proces (thread): abstracte entiteit die de toegekende taken uitvoert communiceert en synchroniseert om toegekende taken uit te voeren processor: fysische entiteit op dewelke processen uitvoeren processen virtualiseren een machine voor de programmeur eerst schrijft men een programma in termen van processen daarna worden de processen toegekend aan processoren

decompositie splits de bewerkingen op in taken die toegekend kunnen worden aan processen taken kunnen statisch en/of dynamisch gecreëerd worden aantal taken kan variëren in de tijd identificeer de concurrency en bepaal op welk niveau je deze wil gebruiken doelstelling: genoeg taken om de processen bezig te houden, maar ook niet te veel aantal taken op een bepaald tijdstip is een bovenlimiet voor de te bereiken speedup

beperkte concurrency: wet van Amdahl fundamentele limiet op parallelle speedup stel fractie s van seq uitvoering is inherent serieel, speedup <= 1/s voorbeeld: berekening in 2 fasen ga over nxn rooster en doe een onafhankelijke berekening ga nogmaals over rooster en vorm som met berekende waarden tijd voor fase één = n2/p fase twee is geserialiseerd door globale variabele, tijd = n2 speedup <= of maximaal 2 methode om speedup te krijgen: verdeel fase 2 in 2 kleinere stappen accumuleer som in deelsommen in elke processor tel alle deelsommen op parallelle tijd is n2/p + n2/p + p, en speedup maximaal 2n2 n2 p + n2 2pn2 2n2 + p2

illustratie van voorbeeld 1 p n2/p n2 work done concurrently Time (c) (b) (a)

concurrency profiles niet eenvoudig om programma te verdelen in serieel en parallel deel vb: opp onder curve is totaal werk, of tijd op 1 processor horizontale as geeft minimum tijd die nodig is wet van Amdahl is geldig op elke overhead, niet alleen op concurrency

toekenning gestructureerde aanpakken werken meestal goed bepaal mechanisme om werk te verdelen over de processen vb. welke processen berekenen welke krachten op welke sterren dit wordt samen met decompositie ook wel partitionering genoemd spreid de belasting, minimaliseer de communicatie en het beheer gestructureerde aanpakken werken meestal goed code inspectie (parallelle lussen) of inzicht in toepassing gekende heuristieken statische versus dynamische toekenning voor programmeurs is partitionering belangrijke taak meestal onafhankelijk van onderliggende architectuur of programmeringsmodel kost en complexiteit van primitieven hebben soms invloed

orkestratie belangrijke elementen die meespelen bij orkestratie naamgeving van gegevens structurering van communicatie synchronisatie organisatie gegevensstructuren en scheduling tijdelijke taken doelstellingen minimaliseer communicatie- en synchronisatiekosten in processoren kies gegevensstructuur ifv lokaliteit van gegevenstoegang schedule de taken zodat afhankelijkheden eerst aan bod komen minimaliseer overhead van beheer van parallellisme staat dicht bij architectuur, programmeringsmodel en taal keuzes hangen af van communicatieabstracties en efficiëntie van primitieven architecten moeten de gepaste primitieven efficiënt aanbieden

mapping na de orkestratie heb je al een parallel programma twee aspecten bij mapping: welke processen voeren uit op zelfde processor welk proces voert uit op welke processor mapping op een bepaalde netwerk topologie één extreem: space-sharing machine verdeeld in subsets, één toepassing per subset processen worden toegekend aan processors, of gelaten voor OS ander extreem: volledige resource management door OS OS doet aan dynamische belastingsspreiding meestal ergens tussen de twee gebruiker kan directieven geven, OS kan deze negeren normaal gezien: proces <-> processor

parallellisering van bewerkingen vs. Data vorige slides concentreren zich op bewerkingen en niet op data bewerkingen worden gedecomposeerd en toegekend (partitioneerd) Partitionering van data is vaak ook een natuurlijke manier bewerkingen volgen de data: eigenaar berekent rooster voorbeeld, data mining, High Performance Fortran (HPF) dit heet “data-parallellisme” data-parallellisme is niet algemeen genoeg datatoegang en communicatie maakt deel uit van orkestratie

doelstellingen High performance (speedup over sequential program)

Granulariteit van parallellisme en uitwerking

Transparante vormen van parallellisme Soort parallellisme granulariteit verantwoordelijkheid en uitvoering elektrische signalen uiterst fijn hardware interregister-transfers, uiterst fijn hardware lezen uit het geheugen, prefetch van instructies pipelining uiterst fijn compiler en hardware gevectoriseerde instr. zeer fijn hardware, parallelliserende compiler en ev. toepassingsprogrammeur (op supercomputers) meerdere pipelines zeer fijn compiler en hardware (in superscalaire processoren)

Niet-transparante vormen van parallellisme Soort parallellisme granulariteit verantwoordelijkheid en uitvoering threads fijn besturingssysteem en (subprocessen, taken) toepassingsprogrammeur (vaak op multiprocessoren) nauw-samenwerkende grof besturingssysteem en processen toepassingsprogrammeur (op multicomputers en op multiprocessoren) los-samenwerkende zeer grof laag boven besturingssysteem (middleware) processen en toepassingsprogrammeur (in wide area networks)

Performantie van parallelle systemen

Performantie van parallelle systemen vaak interesse in hoeveel sneller is een bepaalde parallelle machine vergeleken met een sequentiële machine dit is afhankelijk van het programma dat men draait ! de versnelling (speedup) wordt gedefinieerd als speedup = uitvoeringstijd op 1 processor / uitvoeringstijd op n processoren s = T(1) / T(n) de ideale versnelling die men kan bekomen met n processoren is n

Performantie (vervolg) een speedup van n wordt nooit bekomen omdat niet alle code parallelliseerbaar is de code die parallelliseerbaar is kan niet altijd continu alle middelen bezig houdt (belastingspreiding !) bij de code die wel parallelliseerbaar is men extra overhead moet rekenen voor synchronisatie sommige hulpmiddelen in het systeem toch schaars zijn t.o.v. andere I/O vaak niet parallel verloopt er vaak vertrokken wordt van de sequentiële code die niet herdacht is

Performantie (vervolg) de efficiëntie wordt gedefinieerd als e = T(1) / n*T(n) = s / n als de efficiëntie dicht bij 1 ligt dan gebruik je de hardware zeer goed regel van Minsky (zou gelden voor grote n): s <= log2 n (zonder bewijs) zie grafiek met verschillende versnellings-curve

Performantie (vervolg) wet van Amdahl: T(n) = Ts + Tn / n Ts is de tijd die besteed wordt aan code die intrinsiek serieel Tn is de tijd die parallelliseerbaar is T(1) = Ts + Tn de wet van Amdahl zegt dat er altijd een deel van de code niet parallelliseerbaar is andere regel, afgeleid uit de wet van Amdahl s <= n / ln n