Opgaven Work-Span model Concurrency, 15 nov 2018, Werkgroep.

Transcriptie

1 Opgaven Work-Span model Concurrency, 15 nov 2018, Werkgroep. Gebruik deze opgaven om de stof te oefenen op het werkcollege. Cijfer: Op een toets krijg je meestal zes tot acht opgaven. 1. Uitleg over Efficient en Optimaal: Een parallel algoritme heeft twee complexiteitsparameters, work en span, beide uitgedrukt als functie van de invoergrootte n. Van een goed parallelliseerbaar algoritme accepteren we soms, dat de work hoger is dan de tijd van het beste sequentiële algoritme. De verhouding van (work) gedeeld door (beste sequentiële tijd) is de (parallelliserings-) overhead. Een algoritme heet efficient wanneer de span polylogaritmisch is en de overhead ook polylogaritmisch. Een algoritme heet optimaal wanneer de span polylogaritmisch is en de overhead constant. Oplossing: Geen vraag, dus ook geen antwoord hier. Beoordeling/Toelichting: Nvt. 2. Uitleg over Master Theorem: De Master Theorem geeft je direct de asymptotische oplossing voor recurrente betrekkingen van de vorm T (n) = a.t (n/b)+f(n). Je moet b log a vergelijken met de macht van n in f(n), dus eventuele log-factoren in f even negeren. Als n b log a of f(n) een grotere n-macht heeft dan de ander, is dat meteen het antwoord. Zijn de exponenten gelijk, dan een extra log-factor erbij (bovenop eventuele log s in f die je nu niet verder negeert). Oplossing: Let even op de situatie dat f(n) = n b log a lg k n. De vergelijking tussen f en n b log a zegt dan dat f zwaarder is, maar het overwicht is niet een polynomiale factor, maar een polylogaritmische factor. Volgens de uitleg van de Master Theorem in Cormen, Sectie 4.5, kun je de vergelijking dan niet oplossen. Echter iets verderop in Cormen staat Opgave die juist dit geval oplost tot n b log a lg k+1 n. Het is dus eigenlijk gewoon geval 2 want er is geen polynomiaal overwicht (de mysterieuze n ɛ in het boek). Beoordeling/Toelichting: Verdere studie: (1) College over Recursie bij Datastructuren, (2) Sectie 4.5 uit Cormen, (3) Opgave uit Cormen voor het geval dat f een paar log s bevat, (4) Arne s sheet

2 3. Het Kleinste Verschil: We willen in een oplopend gesorteerde array A van n getallen, het kleinste verschil, KV, van twee opeenvolgende weten. Voorbeeld: in de rij (1, 3, 5, 7, 8, 12, 14, 25) is het KV 1 (namelijk het verschil tussen 8 en 7). Het best mogelijke sequentiële algoritme kost Θ(n) stappen. (a) Kun je het KV berekenen uit het KV van de linkerhelft en het KV van de rechterhelft? (b) Geef een parallel algoritme dat KV berekent. (c) Analyseer work en span van je algoritme met de Master Theorem. (d) Is het algoritme efficient en optimaal? Oplossing: (a) Je moet er rekening mee houden dat het KV, ofwel het KV van links, het KV van rechts is, of het verschil van de laatste links en de eerste rechts. Dus als KV (p, r) het kleinste verschil is van de getallen van index p (inclusief) tot r (exclusief), geldt met q tussen p en r: KV (p, r) = min(kv (p, q), KV (q, r), (a q a q 1 )). (b) Rijen korter dan 4 gaan direct. Vanaf 4: neem q = (p + r)/2 en doe twee (parallelle) KV s en reken de formule uit (a) uit. (c) Work: we doen twee deelaanroepen op halve omvang en een constante hoeveelheid werk dus W (n) = 2W (n/2) + O(1). Met de Master Theorem volgt W (n) = O(n). Span: wat echt na elkaar moet gebeuren is het berekenen van q, èèn deel-kv en het combineren, dus S(n) = S(n/2) + O(1). Met de Master Theorem volgt S(n) = O(lg n). (d) De span is logaritmisch, dus ook polylogaritmisch; de overhead is constant dus ook polylogaritmisch. Efficient betekent polylog span en polylog work, dit is hier van toepassing. Optimaal betekent polylog span en constante overhead, en is hier dus ook van toepassing. Beoordeling/Toelichting: Te behalen 4, voor elke deelvraag 1pt. L = Je kunt ook deel L en deel R laten overlappen. R = Herhaling en Recursie is dubbelop.

3 4. Prefix Sum (Split): De prefix sum van een rij X[0..n 1] is de rij Y [0..n 1], gedefinieerd door Y [k] = k i=0 X[i]. Als alternatief voor het behandelde algoritme bekijken we deze methode: (1) bereken de prefix sum van de linkerhelft en de rechterhelft; (2) tel bij elke uitkomst van de rechterhelft, het totaal van de linkerhelft op. (a) Hoeveel rekenstappen kost het om de prefix sum met een sequentieel algoritme te bepalen? (b) Laat zien, hoe de alternatieve methode werkt, wanneer toegepast op de cijfers van je collegekaart (F=6 als die voorkomt). (c) Stel vergelijkingen op voor de span en het work van de alternatieve methode. (d) Wanneer is een parallel algoritme efficient? Is de alternatieve methode efficient? (e) Wanneer is een parallel algoritme optimaal? Is de alternatieve methode optimaal? Oplossing: (a) Sequentieel kost het O(n) optellingen met: Y[0] = X[0]; for(k=1;k < n;k++) Y[k] = Y[k-1]+X[k] (b) Stel je collegekaartnummer is De linkerhelft is en de rechterhelft is Recursief bepaal je de Prefix Sums: links en rechts Bij de rechterreeks tel je 30 op: Uitkomst is (c) Span: Recursief linker- en rechterhelft berekenen kost S(n/2), maar dit kan tegelijk dus telt in de Span maar een keer. Het linkertotaal kan (op een CREW PRAM) in O(1) tijd worden verdeeld over de rechterprocessors en worden opgeteld bij de elementen rechts. Dus S(n) = S(n/2) + 1. Work: Recursief links en rechts berekenen kost steeds W (n/2), voor de Work moet je beide tellen. Dan nog n/2 optellingen om het linkertotaal bij elk getal van de rechterkant te tellen; totaal is W (n) = 2.W (n/2) + O(n). (d) Efficient is: Work hoogstens polylogaritmisch meer dan sequentieel, en span polylogaritmisch. Dan toch maar even de Master Theorem erbij. Span S(n) = S(n/2) + 1, bloga = 0 en f(n) = 1 = n 0. Dus n bloga = f(n), MT zegt: extra log erbij dus S(n) = O(lg n). Work W (n) = 2.W (n/2) + O(n), bloga = 1 en f(n) = n 1. Dus n bloga = f(n), MT zegt extra log erbij dus W (n) = O(n lg n). We zien een logaritmische Span en Overhead, de methode is dus efficient. (e) Optimaal is: geen (dwz O(1)) overhead en polylog span. De overhead is hier logaritmisch, dus teveel: NIET optimaal. Beoordeling/Toelichting: Elke deelvraag 1pt. Ik kan hier niet het hele verhaal over recursieve algoritmen en recurrente betrekkingen herhalen. De tijd van een recursief algoritme bepalen ZONDER het opstellen van een recurrente betrekking kan alleen Harry Potter!

4 5. Inverse Prefix Sum: Gegeven is een array B. Gevraagd wordt een array A te berekenen, zodanig dat B de PrefixSum is van A. (a) Geef een zo goed mogelijk parallel algoritme hiervoor. (b) Wat zijn work en span van je algoritme? Oplossing: (a) Omdat B[i] de som is van de eerste i getallen, en B[i 1] de som van de eerste i 1 getallen uit A, is A[i] terug te vinden als B[i] B[i 1]. En dat kan parallel: par.for(i, 0, n) A[i] = B[i] - B[i-1] (b) Deze n berekeningen kunnen allemaal tegelijk (superparallel), in work O(n) en span O(1). Beoordeling/Toelichting: Per deelvraag 1pt. Beoordelingscodes: B = Bij recursie moet je een recurrente Betrekking opstellen. C = In het work-span model omschrijf je het algoritme onafhankelijk van het aantal Cores. Je moet geen code maken waarin p, het aantal cores, expliciet voorkomt. Het verdelen over de cores laat je aan de scheduler over. F = Foutief algoritme gegeven (bv voor PrefixSum). Voor een fout algoritme geen punt, soms is bij (b) nog 1/2 gegeven voor een kloppende analyse. M = Masking voor jumpen!! Als je iets(i) wilt doen voor elke index die een veelvoud van j is (het zgn jumpen) dan moet je die j in je loop verwerken, bv. pfor (i, 0, n/j) iets(i*j). Als je hem in een test verwerkt (masking) kost het je alsnog n tijd: pfor (i, 0, n) if (i%j==0) iets(i) doet hetzelfde maar is heel duur! P = Een parallelle loop heeft geen volgorde en loop-carried dependencies zijn niet mogelijk. R = Een Recursief algoritme met logaritmische span levert maar 1/2 (want het moest zo goed mogelijk).

5 6. Work en Span vergelijken: Arnold heeft een parallel algoritme ontworpen met work Θ(n 2 ) en span Θ(lg 2 n). Bert zegt dat zijn eigen algoritme voor deze taak beter is. Bert heeft weliswaar een hogere span, namelijk Θ(lg 3 n), maar zijn work is lager, namelijk Θ(n 1,5 ). (a) Welk algoritme zal beter presteren bij een lineair aantal, dus Θ(n), processors? Leg uit! (b) Welk algoritme zal beter presteren bij een kwadratisch aantal, dus Θ(n 2 ), processors? Leg uit! (c) Voor welke aantallen van processors is Arnolds algoritme sneller? Oplossing: (a) Bij zo weinig processors (namelijk p < w/s voor beide) zijn de algoritmen allebei Work-bound zodat je de tijd kunt schatten als w/p. Arnold loopt in n 2 /n dus lineaire tijd. Bert loopt in n 1,5 /n dus n tijd en dat is veel (nl. polynomiaal) sneller. (b) Bij zoveel processors zijn beide algoritmen Span-bound zodat je de tijd kunt inschatten als s. Arnold gaat hier lg 2 n tijd gebruiken en Bert lg 3 n, zodat hier Arnold de snellere is. (c) Het break even point ligt bij p = n 2 / lg 3 n en bij hogere p is Arnold sneller. Bij dat aantal is Bert al Span-bound en gebruikt lg 3 n tijd, maar meer processors verlagen de tijd niet. Met dat aantal processors is Arnold nog Work-bound, hij gebruikt met p = n 2 / lg 3 n cores ook lg 3 n tijd, maar hij kan het aantal processors nog (tot een factor lg n) verhogen met evenredige speedup. Beoordeling/Toelichting: Per deelvraag een punt. C = Eerst (c) oplossen en daar (a) en (b) uit concluderen is natuurlijk heel slim! Maar (c) was hier wel een beetje als het moeilijkste stuk bedoeld, en veel kandidaten kwamen met een foutieve oplossing voor (c), of pasten de oplossing verkeerd toe. Uiteindelijk is het dan makkelijker om eerst (a) en (b) rechtstreeks op te lossen door de T p expliciet uit te rekenen. G = Voor het break even point moet je Grootste work delen door Grootste span! Als je de formule w 2 /s 1 gaat gebruiken (van p12 van de aantekeningen over work-span model) moet je wel de goeie kiezen voor 1 en 2! P = Als je (c) probeert uit te rekenen met de Plus (ipv de Max) kom je er vrijwel zeker niet uit. U = De Uitleg was te vaag. Heb je bij (a) Bert en bij (b) Arnold, maar zonder kwantitatieve onderbouwing, dan levert dit samen maar 1/2pt. Motiveer bv wanneer een algoritme workbound is (en niet met: p is kleiner dan w, want dat klopt niet). V = Spreek niet van het omslagpunt want de omslag tussen work en span bound is per algoritme Verschillend.

6 7. Parallelle Eennummers: Gegeven een reeks A van nullen en enen. Het eennummer van een positie met waarde 1 geeft aan, de hoeveelste opeenvolgende 1 het is. Een positie met waarde 0 heeft eennummer 0. Voor zijn de eennummers Piets Recursieve Eennummeraar berekent eerst de PRE van het linker- en rechterdeel: PRE(A,p,r) { // Zet A[p,...,r-1] om naar eennummers q=(p+r)/2 ; Invoke (PRE(A,p,q), PRE(A,q,r)) ; (a) Hoe ziet de voorbeeldrij er hierna uit, en wat moet er dan nog gebeuren? (b) Maak Piets programma af. (c) Analyseer work en span (met de Master Theorem). (d) Is Piets algoritme efficient en optimaal? Oplossing: (a) Het resultaat van en is en In de hele rij zijn de enen in het eerste segmentje van de rechter deelrij onderdeel van een langere run, en daar moet je het laatste antwoord van links (2) nog bijtellen. (b) Het ophogen van het eerste segment rechts kan sequentieel zo: i = q ; while (i<r && A[i]>0) A[i++]+=A[q-1]; maar dat kost lineaire span en levert een slecht parallel algoritme. Slimmer is dat elke positie aan zijn uitkomst kan zien of hij in het beginsegment zit: Parallel.For(q, r, (i) => { if (A[i] == i-q+1) A[i]+=A[q-1];}). Aan een rij van lengte 0 of 1 hoef je niks te doen dus vooraan hoort if (r <= p+1) return; maar voor die ene punt hoef je dat niet te zeggen. (c) Beide oplossingen geven lineair werk na de recursies, dus W (n) = 2W (n/2) + O(n) met oplossing n lg n. De eerste geeft lineaire extra span dus S(n) = S(n/2) + O(n) met oplossing n; weinig bevredigend aangezien het sequentieel in lineaire tijd kan. De tweede geeft constante extra span dus S(n) = S(n/2) + O(1) met oplossing lg n. (d) De span is logaritmisch, dus ook polylogaritmisch; de overhead is logaritmisch (sequentieel kan het lineair) dus ook polylogaritmisch. Efficient betekent polylog span en polylog overhead, dit is hier van toepassing. Optimaal betekent polylog span en constante overhead, en is hier niet van toepassing. Beoordeling/Toelichting: Totaal tot 4 pt, een per deelvraag. Voor de volle punten moest je de superparallelle combinatiemethode uitvinden, maar met inzicht in recursie en Master Theorem kon je al snel 3pt binnenharken. A = Je hebt iets Anders geanalyseerd dan je eigen methode. C = Jouw combinatiecode is een Complete sequentiële oplossing. H = Bij (b) sequentiële code maar bij (c) reken je O(1) span; Hoe? L = Beste sequentiële tijd is Lineair. P = Verhoog rechts alle Positieve A[j]; Foute uitkomst. R = Snap je Recursie wel? Bij het ontwerpen ga je ervan uit dat een aanroep werkt, ook al heb je de methode nog niet geschreven. S = Als je Sequentieel combineert krijg je geen punt voor (b). Mogelijk nog voor c (als je lineaire span vindt) en d (nee, nee). Eennummereren kan overigens met een optimaal parallel algoritme door de uitkomst als functie-compositie te schrijven en de principes van prefix sum te gebruiken. Definieer functies f 0 (x) = 0 en f 1 (x) = x + 1, dan is de uitkomst voor A[i] precies de compositie van f A[0] t/m f A[i] met argument 0. De functiecompositie kun je als scan berekenen.

7 8. Parallel MaxOneRow: De MaxOneRow van een rij bits is het maximale aantal aaneengesloten 1-en; bv van is de MaxOneRow 5 (zie posities 7 en 14). Je kunt de MaxOneRow berekenen met een recursieve module die van een rij bits deze drie waarden oplevert: p: het aantal 1-en waarmee de rij begint; i: de MaxOneRow; s: het aantal 1-en waar de rij op eindigt. (a) Wat is de beste sequentiele tijd om de MaxOneRow te berekenen? (b) Hoe vind je de p, i en s van een rij uit die van de linker- en rechterhelft? (c) Analyseer de work van het resulterende algoritme. (d) Analyseer de span van het resulterende algoritme. (e) Is het parallelle algoritme efficient en is het optimaal? Leg uit! Oplossing: (a) O(n). Het kan niet sublineair maar dat hoef je niet te bewijzen. Lineair algo: c=0; m=0; // Current en Max aantal enen op rij for (i=0; i<n; i++) { c = (A[i])? c+1 : 0; m = (c>m)? c : m; } (b) Stel rij S heeft linker- en rechterdeel L en R. S.p = (L.p < L.length)? L.p : L.length + R.p; S.i = max(l.i, L.s+R.p, R.i); S.s = (R.s < R.length)? R.s : R.length + L.s; (c) Het combineren is constant veel werk dus voor work vind je W (n) = 2.W (n/2) + O(1) met oplossing W (n) = O(n). (d) Het combineren is constant veel werk (de drie waarden kunnen zelfs parallel) en de deelrijen zijn onafhankelijk dus je vindt S(n) = S(n/2) + O(1) met oplossing S(n) = O(lg n). (e) De span is logaritmisch en het werk lineair, hetzelfde als de sequentiele berekening, dus er is constante overhead. Daarmee is het algoritme zowel efficient (polylog span en polylog overhead) als optimaal (polylog span en constante overhead). Beoordeling/Toelichting: Maximaal 5pt, per deelantwoord een punt indien juiste methodiek toegepast. Ik houd er geen casino op na dus gokken wordt niet beloond! Codes: B = Zegt dat vanwege Binaire operaties, span Ω(lg n) optimaal is. Onjuist, er is hier Superparallellisme mogelijk waarmee je MOR oplost in O(1) tijd. Ik weet nog niet of je O(n 3 ) of O(n 4 ) cores nodig hebt. C = Zegt: Het Creëren van de sublijsten kost Ω(n). Nou, dat moest je dan maar gewoon niet doen! Geef nooit de lijsten zelf als argument mee, maar begin- en eindpositie van een segment ervan. D = Vergeet bij (b) het geval van Doorloop prefix (dus zegt: S.p = L.p), -1/2. H = Zegt bij (a) O(n) maar niet Hoe, 1/2. L = Vergelijk bij (b) de L.p en R.s met de lengte en niet met n/2; door afronding is dat niet altijd t zelfde. M = Motivatie/berekening onjuist of ontbreekt. R = Voor een Recursief algoritme moet je beschrijven hoe je deeloplossingen samenvoegt (daar werd ook expliciet om gevraagd), niet hoe je de instanties verder en verder verdeelt. S = Zegt niets over Span bij (e). U = Uitkomst ontbreekt of fout.

8 V = Bij (c/d) heb je de berekeningen van work en span Verwisseld; samen 1pt. W = Bij (e) moet ook Work polylog zijn.

9 9. Parallelle Polynoom-evaluatie: Een polynoom van graad n is een expressie van de vorm n k=0 a k x k. Onder het evalueren verstaan we het uitrekenen van de waarde, gegeven de coëfficiënten a 0 t/m a n en het argument x. Sequentieel kan dit met n vermenigvuldigingen en n optellingen. Je kunt een snel parallel algoritme krijgen, door de expressie te herschrijven tot een polynoom van graad n/2 in de parameter x 2 : a + b.x 1 +c.x 2 + d.x 3 +e.x 4 + f.x 5 +g.x 6 + h.x 7 = (a + b.x) +(c + d.x).(x 2 ) 1 +(e + f.x).(x 2 ) 2 +(g + h.x).(x 2 ) 3 (a) Geef expressies voor de coëfficiënten a 0 t/m a n/2 en de parameter x van het nieuwe polynoom. (b) Geef een recurrente betrekking voor de work en span van een parallel algoritme dat zo het polynoom evalueert. (c) Los de vergelijkingen voor work en span op met de Master Theorem. (d) Is deze methode efficient? En is hij optimaal? Leg uit! Oplossing: (a) Neem, voor k van 0 tot n/2: a k = a 2k + a 2k+1.x. (Detail mag je negeren: als n even is, loopt k tot precies n/2 en dan is 2.k + 1 groter dan n; neem dan a n+1 = 0.) Neem x = x.x. (b) Het uitrekenen van a k kost een vermenigvuldiging en een optelling, je moet dit n/2 keer doen, dus samen n handelingen. Het kwadrateren valt daarbij in het niet. Voor de work betekent dit W (n) = O(n) + W (n/2). Je kunt alle a en x parallel uitrekenen, dat kost maar 2 stappen na elkaar: S(n) = 2 + S(n/2). (c) Even met de MasterTheorem erover heen. Eerst W : n b log a is n 0 is 1, dus de basisterm n is polynomiaal meer zodat W (n) = O(n). Dan S: n b log a is n 0 is constant, net als de basisterm. Ze zijn dus gelijk in O(), dus extra log erbij: S(n) = O(lg n). (d) De span is O(lg n), dat valt onder Polylogaritmisch. De overhead is werk/sequentieel is O(1) dus constant. Efficient wil zeggen: Polylog span en Polylog overhead, hieraan is voldaan. Optimaal wil zeggen: Polylog span en constante overhead, hieraan is voldaan. Het is dus efficient EN optimaal. Beoordeling/Toelichting: Voor elke deelvraag een punt. Verdere codes: C = Bij (a) een antwoord (bv. n/2 k=0 (a 2k + a 2k+1 x)(x 2 ) k ) met de gevraagde coëfficienten in een Formule verpakt, volledige punt. D = Kent bij (d) Definitie van efficient en optimaal en past goed toe, 1pt. F = Bij (b) Foute formule zonder uitleg, 0pt. R = Betrekking bij (b) is helemaal niet Recurrent (bv W (n) = n/2 + O(n)), 0pt. S = Zegt bij (a) wel de Speciale gevallen a 0 = a+bx en a 1 = c+dx, maar niet de algemene formule, 1/2pt. V = Verkeerde Vergelijking goed opgelost bij (c), 1/2. Als je denkt dat je het nou goed snapt, probeer dan eens dezelfde vragen te beantwoorden met de formule: a + b.x 1 + c.x 2 + d.x 3 +e.x 4 + f.x 5 + g.x 6 + h.x 7 = (a + b.x + c.x 2 + d.x 3 ) +(e + f.x + g.x 2 + h.x 3 ).x 4

10 10. Parallelle Plip-King: Plipper is een nieuw sociaal netwerk waar deelnemers maar 1 ding kunnen doen namelijk andere deelnemers plippen (je kunt niet jezelf plippen). In een groep A van deelnemers is x een Plip-King als hij door alle anderen in A geplipt is, maar zelf niemand in A plipt. Een verzameling van n 2 deelnemers kan nul of een Kings bevatten, maar niet meer. Hoewel de informatie over onderling plipgedrag van n deelnemers in totaal bijna n 2 bits bevat, is het mogelijk om sequentieel in lineaire (dwz., O(n)) tijd te bepalen of die groep een Plip-King heeft. Deze opdracht kijkt naar een parallel Plip-King algoritme. Voor identifiers i en j kun je in O(1) (dus constante) tijd opvragen of i j plipt. Om te bepalen of groep A van n personen een King heeft, splitsen we A in twee groepen A 1 en A 2, en bepalen recursief of die een Plip-King hebben. (a) Als A een King heeft, dan moet dat de King van A 1 of A 2 zijn. Wat moet je doen om te controleren of de deel-kings inderdaad King van A zijn? (b) Stel vergelijkingen op voor de Work en Span van dit algoritme. (c) Wat is de uitkomst van de Work en Span? (d) Is dit algoritme efficient? Is het optimaal? Oplossing: (a) Uit de definitie van King volgt dat als x King is in A, hij dit ook is in een deelverzameling (waar hij in zit). Als x King van A 1 is, plipt hij daarin niemand en wordt door iedereen daar geplipt. Hij zal dus King van A zijn, als hij ook in A 2 niemand plipt en door alle leden van A 2 wordt geplipt. Dit controleren kost n handelingen, die allemaal parallel kunnen, en conjunctie van de uitkomst kan ook in constante span op een CRCW PRAM. (b) Na de twee deelaanroepen moet je nog lineair veel werk doen met constante span. De deelaanroepen kunnen volledig parallel. Dus je vindt voor het Work: W (n) = 2 W (n/2)+ O(n). Je vindt voor de Span: S(n) = S(n/2) + O(1). (c) Oplossing met de Master Theorem (benoem a, b en f) levert W (n) = n lg n en S(n) = lg n. (d) De span is gelukkig logaritmisch, wat snel genoeg is om de methode efficient en optimaal te noemen. Helaas is er (omdat er een sequentieel lineair algoritme bestaat) sprake van een niet-triviale, namelijk logaritmische, overhead. Het algoritme is daarom wel efficient, maar niet optimaal. Beoordeling/Toelichting: Per deelvraag een punt tot een totaal van 4. A = Er is niet Altijd een plip-king, je moet dit echt wel echt checken! B = Bij (c) alleen 1 als je Beide vergelijkingen goed oplost, en het de goede vergelijkingen zijn! C = Als je van een EW (dus niet CW) PRAM uitgaat, kost conjunctie logaritmische span. ook kon je voor het combineren van de tests verwijzen naar de Reduce, die logaritmische span heeft. De spanvergelijking wordt dan S(n) = S(n/2)+lg n met oplossing S(n) = lg 2 n. Het algoritme is nog steeds efficient maar niet optimaal. E = Kijk alleen of de deelkings Elkaar plippen; dit is niet genoeg, levert flase positives op. H = Je bent de Halve check vergeten (alleen of de King niemand plipt, of alleen dat hie door iedereen wordt geplipt). Omdat dit voor de complexiteit geen verschil maakt, geen aftrek. K = Redenering Klopt maar is gebaseerd op onjuiste conclusie van vorige deelvraag. Je

11 kon dus wel deelpunten krijgen als je een fout maakte en daarmee goed verder werkte, maar meestal niet de volle punten. Je krijgt geen punten als je een onderdeel fout doet, en het volgende onderdeel weer fout doet maar per ongeluk op het juiste antwoord komt. L = Jouw work is Lager dan de tijd van het beste sequentiele algoritme (de overhead is significant kleiner dan 1). Dit kan helemaal niet! Want het sequentieel uitrollen van jouw algoritme zou dan een betere sequentiele oplossing geven. S = Niet gezien dat de checks parallel kunnen, dus in constante of log span, half aftrek. T = Je moet bij recursieve algoritmen de Mastertheorem Toepassen! De redenering je doet zoveel werk en er zijn zoveel recursienivo s zou bij alle recurrente betrekkingen de uitkomst f(n) lg n geven, en dat is niet zo. Z = King uit A 1 de Zelfde als uit A 2 ; kan niet, want de groepen overlappen elkaar niet. Je krijgt een beter algoritme als je zoekt naar een Plip-Prince. Een Prince is een deelnemer, waarvan je weliswaar nog niet hebt vastgesteld dat hij King is, maar die de enige mogelijkheid is omdat je van alle anderen in de verzameling al hebt gezien dat ze iemand plippen, of geplipt worden. Als A een singleton is, lever de enige deelnemer op als Prince. Als A meer elementen heeft, splits in A 1 en A 2 en zoek Princes x 1 en x 2. Kijk hierna alleen maar of x 1, x 2 plipt. Zoja, dan is x 1 uitgesloten als King (want hij plipt x 2 ) en x 2 is Prince. Zonee, dan is x 2 uitgesloten (want x 1 plipt hem niet) dus x 1 is Prince. Dit recursieve algoritme geeft voor je hele verzameling A in logaritmische span en lineair work een Prince. Je moet dan aan het eind alleen checken (lineair work) of deze Prince inderdaad King is. De eindcheck kost constante span op een CW PRAM en logaritmisch op een EW PRAM. In beide gevallen levert dit logaritmische span voor het totaal, want je doet deze eindcheck maar 1 keer, en niet op elke laag van de recursie.

12 11. Integer vermenigvuldigen: Gegeven integers A en B, als rijen van n (decimale) cijfers. Je moet het product C berekenen, als rij van 2n cijfers. Sequentieel kan dit in O(n 2 ) tijd door elk cijfer van A te combineren met elk cijfer van B. (a) Geef een parallel algoritme met kwadratische work en lineaire span. (b) Is dit algoritme efficient, en is het optimaal? (c) Is een beter algoritme dan onder (a) mogelijk? Oplossing: (a) De bottleneck in het parallel uitrekenen is het doorgeven van de carry, dwz., als er in een positie in C een waarde grotergelijk 10 staat, moeten veelvouden van 10 overgebracht worden naar de volgende positie. Reken eerst de cijfers van C uit zonder carry; er kunnen dan tijdelijk waarden grotergelijk 10 staan. De waarden in C[i] representeren 10 i en omdat je een 10 i -term krijgt als product van een 10 j -term en een 10 i j -term, vind je de juiste waarde door A[j].[B[i j] te sommeren. Het doorschuiven van de carry kan niet zomaar parallel, omdat een doorgeschoven carry naar een kolom, ook de carry vanaf die kolom kan veranderen. p.for (i, 0, 2*n) { C[i] = 0; pfor (j,..,..) C[i] += A[j]*B[i-j] } ; int carry = 0; for (int i=0; i<= 2*n; i++) { C[i] += carry; carry = C[i] / 10; C[i] -= (10*carry); } (b) Zowel optimaal als efficient vereisen polylogaritmische span, die je hier niet hebt, dus geen van beide. Overhead is O(1) dus goed genoeg voor beide, jammer van de Span! (c) Gebruik het recursieve algoritme van Karatsuba (op basis van drie vermenigvuldigingen van halve lengte). Met parallelle subvermenigvuldigingen en lineaire optelling krijg je S(n) = S(n/2) + O(n) = O(n) en W (n) = 3W (n/2) + O(n) = O(n 1,585 ). Wel beter, nog steeds niet efficient of optimaal. Interessantere uitdaging is natuurlijk, het doorgeven van de carry te versnellen tot polylogaritmisch. Met binaire carry is dit goed te doen (zie cayyr prediction), dus ik denk dat het voor decimale carry s ook kan. Het optellen van de (lineair veel) producten voor de eerste fase van C[i] kan natuurlijk wel parallel in lineair work en log span. Beoordeling/Toelichting: Totaal 3pt, een per deelvraag.

13 12. Sink: Gegeven is een verzameling van n punten, waarbij voor de meeste een ander punt als opvolger is gegeven. Een punt zonder opvolger heet een sink; de opvolger-relatie heeft geen cykel; de opvolger van i staat in p[i]. Interpretatie: een druppel water in punt i rolt naar punt p i, uiteindelijk verzamelen alle druppels zich in sinks. Het stroomgebied van sink a is de verzameling punten met een pad naar a. Doel: bereken een array s zodanig dat s[i] = a voor alle i in het stroomgebied van a. (a) Geef een sequentieel algoritme dat alle stroomgebieden berekent. Hint: dit kan in lineaire tijd. (b) Voor een parallel stroom-algoritme, kopieren we eerst p[i] naar s[i] en laten sinks naar zichzelf wijzen met if (s[i]==-1) s[i]=i;. Bedenk en leg uit, wat er gebeurt in een ronde van pointer doubling: pfor (0, n, (i)=>s[i]=s[s[i]]). (c) Geef nu een parallel algoritme dat stroomgebieden uitrekent. (d) Analyseer het algoritme en benoem of het efficient en/of optimaal is. Oplossing: (a) Dit kan met Depth-First Search of, omdat er geen vertakkingen zijn, met een wat versimpelde variant ervan. Loop voor een ongelabelde i het p-pad af, tot je bij een sink a of een al met a gelabeld punt komt. Geef alle punten op het pad s-label a. (b) De eigenschap dat sinks gekenmerkt worden door i = s i blijft gelukkig behouden want als s i = i dan is ook s si = i. Punten die direct naar een sink wijzen, houden dezelfde waarde. Verder gaat elk punt direct naar zijn op-opvolger wijzen, waardoor alle paden (naar sinks) tweemaal zo kort worden! De graaf houdt hetzelfde antwoord voor het stroomgebiedprobleem, maar wordt tweemaal zo plat. (c) Omdat paden hoogstens lineaire lengte kunnen hebben, zijn lg n rondes van pointer doubling voldoende om alle paden tot lengte 1 te reduceren. Dus: na lg n keer pfor (0, n, (i)=>s[i]=s[s[i]]) wijzen sinks nog steeds naar zichzelf, en non-sinks hebben een pad van lengte 1 naar hun sink. Dit is hetzelfde als: elke s[i] heeft de waarde van het stroomgebied. (d) Een ronde kost lineair werk (elke s[i] wordt ververst) maar dit kan allemaal tegelijk (op een CREW PRAM; meerdere i kunnen tegelijk s[s[i]] lezen) dus in span O(1). De lg n-voudige herhaling leidt tot werk O(n lg n) en span O(lg n). Omdat het sequentieel in lineaire tijd kan, is er sprake van een logaritmische overhead. Het algoritme is daarom wel efficient, maar niet optimaal. Beoordeling/Toelichting: Beoordelingscodes: M = Omdat het algoritme niet recursief is, hoef je de Master Theorem niet van stal te halen.

14 13. Goed en slecht Greedy Schedule: De lengte van een Greedy Schedule kan variëren, afhankelijk van welke ready stappen de scheduler kiest. Geef een voorbeeld van een berekeningsgraaf en twee Greedy Schedules, elk op drie cores, waarbij het ene schedule minstens anderhalf keer zo lang duurt als het andere. (b) Is het mogelijk een voorbeeld te geven waarin een slecht Greedy Schedule meer dan tweeënhalf maal zo lang is als een goed Greedy Schedule? Oplossing: (a) (Omdat dit een voorbeeld is, kan een goed antwoord er compleet anders uitzien!) De graaf heeft 180 knopen, zestig zijn sequentieel afhankelijk in een sliert, de andere 120 zijn helemaal onafhankelijk. Schedule 1: werk eerst de losse knopen af (die zijn allemaal ready) in 40 rondes, dan is de sliert nog over en die kost 60 rondes (waarin maar één core actief is). Schedule 2: neem per ronde de ene ready stap van de sliert en twee losse, dit kost 60 rondes. (b) Volgens de Scheduling theorie van Brent kan een GS niet langer zijn dan tweemaal het beste schema, dus ook niet langer dan tweemaal een ander GS. Beoordeling/Toelichting: Twee punten voor goed beargumenteerd en uitgewerkt voorbeeld. En 1 voor (b). Codes: K = Idee wel aardig, maar je ratio is Kleiner dan 1,5. T = Dit zijn Twee verschillende berekeningen. 14. Greedy Schedule: Een paralelle berekening met work w en span s moet worden uitgevoerd op een machine met p cores en je wilt dit doen volgens een Greedy Schedule. (a) Beschrijf hoe een greedy schedule tot stand komt. (b) Waarom is de lengte t van dit schedule begrensd door w p + s? (c) Je baas vindt dit niet snel genoeg, volgens hem werkt de computer van jullie concurrent viermaal zo snel. Kun je de concurrent inhalen met een betere scheduling? Oplossing: (a) Het Greedy Schedule kiest in elke ronde een maximaal aantal ready stappen. Dit zijn er p in een volle (core-bound) ronde, of minder in een lege (ready-bound) ronde. (b) Omdat een volle ronde p stappen uitvoert, zijn er daavan hoogstens w/p. Omdat een lege ronde de span van de (resterende) berekening verlaagt, zijn er daar hoogstens s van. Het aantal rondes is dus begrensd door w + s. p (c) Met alleen betere scheduling zal dit niet gaan, omdat Greedy Scheduling 2-Optimaal is. Elk schedule gebruikt minstens max( w, s) stappen, en dit is meer dan de helft van jullie p aantal w + s. Om viermaal zo snel te worden, zul je dus een beter algoritme of een snellere p computer moeten maken. Beoordeling/Toelichting: Te behalen 3pt, voor elk onderdeel 1. N = Je bewijst wel dat w/p + s Nodig is, maar niet dat t voor dit schedule genoeg is. T = Voor volle punt moet de Twee-optimaliteit wel genoemd worden. W = Work en Span zijn geen aparte delen van de berekening (als in: verwerk eerst de work en daarna de span), maar twee eigenschappen ervan.

15 15. Omslagpunt work en span: Voor zekere taak heb je een parallel algoritme A1 met work w 1 en span s 1. Er is een alternatief algoritme A2 met slechter work w 2 > w 1 maar betere span s 2 < s 1. Voor welke aantallen cores, p, verwacht je van A2 een lagere rekentijd dan van A1? (Geef je antwoord asymptotisch, dus in grote-o of Θ.) Oplossing: Het antwoord is p w 2 /s 1. Volgens de scheduling-theorie van Brent is de rekentijd van A ongeveer w/p zolang p w/s, de work-bound fase, en ongeveer s wanneer p w/s, de span-bound fase. Door dit in een grafiekje uit te beelden, zie je dat A2, A1 inhaalt bij p = w 2 /s 1. Beoordeling/Toelichting: Voor goed antwoord met enige toelichting 3pt. Als je alleen hebt klein of groot aantal, dan 1pt. S = A1 wordt Span-bound bij p = w 1 /s 1, maar pas ingehaald bij een iets hogere p.

16 16. Parallel Maximum: We willen het grootste getal uit een array A van n verschillende getallen bepalen op een CRCW PRAM. (a) Laat zien hoe de CRCW PRAM de conjunctie van n condities c i, dus c 1 c 2... c n, kan bepalen in lineair (dus O(n)) werk en constante (dus O(1)) span. (b) Laat zien hoe het mogelijk is om het maximum van een array A van n getallen te bepalen met kwadratisch veel werk in constante span. (c) Geef een methode om het maximum te bepalen in O(n n) work en constante span. Hint: Verdeel de invoer in n groepjes. Oplossing: (a) Dit is het duale van de OR (die op hoorcollege is voorgedaan): (1) R = true; (2) par.for(i, 1, n) if (!c[i]) R = false; Na afloop is R true wanneer alle c i true zijn, en false wanneer minstens 1 c i false is, dus de conjunctie. (b) Kom op het idee om (a) toe te passen. Getal A[p] is het maximum van de array als geldt dat voor alle i: A[p] A[i], wat precies een conjunctie van n condities is. (Als je dit opmerkt, je beroept op (a), en voldoende duidelijk uitlegt dat de gewenste span en work gehaald worden, kreeg je hier al je punt.) Dat checken we voor alle mogelijke p parallel volgens de truuk van (a). Regel 1 stelt voor elke p de waarde op plek p kandidaat. Regel 2 slaat p weer knockout als er enig getal i groter is. Regel 3 schrijft de (enige) overgebleven kandidaat naar de uitvoer. (1) par.for(p, 1, n) k[p] = true; (2) par.for(p, 1, n) par.for(i, 1, n) if (A[i] > A[p]) k[p] = false; (3) par.for(p, 1, n) if (k[p]) result = A[p]; Het werkt ook prima trouwens als je de drie parallele loops tot eentje combineert. (c) Zo n hint staat er vast niet voor niets. Als ik de invoer van n getallen verdeel in s = n groepjes, heeft elk groepje omvang n/s ofwel omvang s. In elk groepje kan ik, volgens de methode van (b), het maximum vinden in constante span met s 2, dus n, werk. Voor de n goepjes samen is dit dus O(n n) werk en, omdat de groepjes onafhankelijk zijn, nog steeds constante span. Hierna zit ik nog met n groepswinnaars, ik heb dan nog n werk en constante span nodig om (weer met de methode uit (b)) het uiteindelijke maximum te bepalen. Beoordeling/Toelichting: Per deelvraag een punt. Je kunt (a) zien als een kennisvraag, (b) als een toepassingsvraag en (c) als doordenkvraag. Beoordelingscodes: A = Jij laat Alle threads de c i schrijven naar R. Resultaat is dan niet per se de conjunctie, maar de waarde van de laatst schrijvende thread. B = Waarom elke c i vergelijken met zijn Buur? Overbodig! C = Onduidelijk hoe de deelresultaten gecombineerd worden. Er bestaat geen Concurrent Return op de CRCW PRAM! L = Concurrent Read/Write slaat op operaties op dezelfde Locatie. OR = Er werd gevraagd om AND maar jij geeft OR, 1/2pt. R = Een recursieve oplossing kost logaritmische span. Elk ander schema dat volgens een boomplan paarsgewijze competities houdt ook. U = Een Update zoals R = R && c[i]; of if (A[i] > max) max = A[i]; is inherent sequentieel en kan niet parallel, zelfs niet op een CRCW PRAM.

17 17. Lengte van Greedy Schedule: Een parallelle berekening met work w en span s wordt uitgevoerd op p cores volgens een Greedy Schedule. Om het aantal rondes te beredeneren, letten we speciaal op die rondes waarin de span van de resterende berekeningsgraaf afneemt; zulke rondes noemen we krimpend. (a) Beschrijf hoe een greedy schedule tot stand komt. (b) Bewijs dat er exact s krimpende rondes zijn. (c) Bewijs dat er hoogstens w s niet-krimpende rondes zijn en dat de lengte van de schedule begrensd is door s + p w s p. Oplossing: (a) De Greedy Scheduler kiest in elke ronde een maximaal aantal ready stappen. Dit zijn er p in een volle (core-bound) ronde, of minder in een lege (ready-bound) ronde. Een lege ronde is krimpend omdat alle ready stappen worden uitgevoerd, dus alle ketens in lengte afnemen. Een niet-krimpende ronde is dus altijd vol. (b) In het begin is de langste keten in de graaf s operaties. Geen enkele ronde kan de langste keten meer dan 1 doen afnemen, omdat er van de keten maar 1 operatie kan worden uitgevoerd. Elke afname is dus een afname met 1, zodat het aantal afnames s is. (c) Omdat elke krimpende ronde minstens 1 operatie uitvoert, en er daar exact s van zijn, worden er hoogstens w s operaties in niet-krimpende rondes gedaan. Een niet-krimpende ronde kiest niet alle ready stappen, dus is vol en voert p operaties uit. Hun aantal is dus begrensd door w s w s, en daarom het totaal aantal ronden (inc. krimpende) door s +. p p Beoordeling/Toelichting: Te behalen 3pt, voor elk onderdeel 1. E = Benoem/bewijs dat de span hoogstens 1 kan afnemen per ronde. L = De Laatste conclusie van (c) volgt direct uit de andere twee dingen die je moest beredeneren, en alleen deze Laatste conclusie levert geen punt op. R = Een greedy scheduler maakt geen Random keuze uit de ready stappen, maar een non-deterministische. S = Je kunt een berekening niet Splitsen in een span-pad en non-span knopen. In veel antwoorden werd er geredeneerd alsof er een sliert van s knopen is die in s ronden wordt verwerkt, plus w s knopen die dan vanzelf allemaal in ronden van p kunnen. Work en span zijn geen aparte delen van de berekeningsgraaf, maar twee eigenschappen van die graaf. U = Het langste pad in de graaf is niet Uniek! V = Benoem/beargumenteer dat een niet-krimpende ronde Vol is (dus p stapen doet). W = Maximaal aantal ready stappen klopt maar is erg summier; zeg Waardoor dit beperkt wordt (minder ready s dan cores, of alle cores bezet). Z = Greedy neemt Zoveel mogelijk ready stappen, maar het maakt niet uit welke. Ready verkiezen boven non-ready is onzinnig omdat non-ready stappen helemaal niet kunnen/mogen.

18 18. QuickSort: QuickSort verdeelt de invoer rond één gekozen waarde, de pivot, in een deel elementen kleinergelijk de pivot en een deel grotergelijk dan de pivot. Deze twee delen worden met een recursieve aanroep gesorteerd. Het verdelen, de Partition, is een sequentieel proces dat lineair veel werk kost. (a) Neem aan dat de twee delen ongeveer even groot zijn en analyseer de tijd voor sequentiele QuickSort; dwz., geef een recurrente betrekking en los die op. (b) Analyseer de span van QuickSort wanneer de twee recursieve aanroepen parallel worden gedaan. (c) Het is mogelijk, Partition te parallelliseren tot O(lg n) span. Analyseer de Span van QuickSort als deze Partition wordt gebruikt. Oplossing: (a) Het sorteren kost lineaire tijd voor Partition plus twee recursieve aanroepen; als die ongeveer even groot zijn, voldoet de tijd Q(n) voor het sorteren van n elementen aan Q(n) = O(n) + 2Q(n/2). Gevalletje Master Theorem met a = 2, b = 2, f(n) = O(n) dus n 1. Omdat ook b log a = 1 komt er een lg bij en is Q(n) = O(n lg n). (b) Noem de span S(n) voor het sorteren van n elementen. Het verdelen is hier lineaire tijd en sequentieel en dit betekent span O(n). De twee recursieve aanroepen verlopen parallel en geven daarom maar de span van eentje, zodat S(n) = O(n) + S(n/2). Gevalletje Master Theorem met a = 1, b = 2, f(n) = O(n) dus n 1. Omdat b log a = 0, domineert f(n) polynomiaal dus S(n) = n. (c) Noem de span met deze parallelle Partition T (n). De span bestaat uit de span voor Partition plus die van de recursieve aanroep, die we maar eenmaal tellen omdat de twee aanroepen parallel gaan. Dus T (n) = O(lg n) + T (n/2). Gevalletje Master Theorem met a = 1, b = 2, f(n) = O(lg n) dus n 0 lg n. Omdat b log a = 0 wel f(n) domineert, maar slechts met een lg n factor dus niet polynomiaal, een extra lg n factor erbij: T (n) = lg 2 n. Beoordeling/Toelichting: Per deelvraag een punt. A = Als het antwoord ontbreekt of fout is, 0pt voor deze deelvraag. B = Als de recurrente Betrekking ontbreekt of fout is, hoogstens 1/2. Een veelgemaakte fout is het vergeten van de functie in de RHS, dus bv Q(n) = 2.(n/2)+O(n). Als je de letter O gebruikt om de functie aan te duiden, wordt de vergelijking O(n) = 2O(n/2)+O(n), wat heel onduidelijk is (fout eigenlijk) dus dat moet je niet doen! E = De log-factor bij Evenwicht is Extra, dus komt bovenop de grootste waarde. De gedachte er is evenwicht dus de uitkomst is O(lg n) is onjuist! L = De Log factor bij (c) werd vaak vergeten. Op de MT-schaal liggen n 0 en lg n, waarbij veel deelnemers wel zagen dat lg n domineert, maar dachten dat dit genoeg was om het antwoord te zijn. De dominantie is hier slechts logaritmisch en daarom is een extra log nodig. P = Het Product nemen van f(n) en de recursiediepte is een foute methode, waarvan het resultaat alleen toevalligerwijs met de juiste waarde kan overeenstemmen. T = Bij (a) wordt om de Tijd van een sequentieel algoritme gevraagd, en moet je geen onderscheid maken tussen Work en Span. V = Voor en na de = moet je dezelfde letter hebben, dus niet zoiets als S(n) = 2Q(n/2) + O(n), want dan is het geen recurrente betrekking!