Översikt. Parallella sökalgoritmer för diskreta optimeringsproblem. 8-pusslet. Problemdefinitioner

Transkript

1 Översikt 2 Parallella sökalgoritmer för diskreta optimeringsproblem Kumar et. al. Introduction to Parallel Computing Kapitel 11 Robert Granat efter material från Mikael Rännar och Erik Elmroth 5/ l Problemdefinitioner l Problemexempel l Heuristik l Sekventiella sökalgoritmer Djupet först (DFS) Bäst först l Sökningsoverhead l Parallell DFS Statisk lastbalansering Dynamisk lastbalansering l Parallella DFS branch & bound Iterativ fördjupning A* l Att upptäcka terminering Dijkstras algoritm Trädbaserad algoritm l Parallella bäst-först-algoritmer Centraliserad öppen-lista Distribuerad öppenlista l Parallella DFS-algoritmer på SIMD l M.m. Problemdefinitioner 3 8-pusslet 4 Ett DOP beskrivs av tupeln (S, f) där S är mängden av tillåtna lösningar (som uppfyller vissa bivillkor) f är en kostnadsfunktion: f : S R (reella talen) l Problemet kan beskrivas som att finna en tillåten lösning x opt sådan att f(x opt ) f(x) för alla x S Finn kortast möjliga söksekvens från starttillstånd (a) till sluttillstånd (b) kostnadsfunktionen f = #flyttningar l Ett DOP kan omformuleras som problemet att i en graf finna den stig som ger minimal kostnad från ett starthörn till ett av flera möjliga målhörn l f är definierad i kostnaden att traversera kanter i grafen, som summan av stigens kanter l Grafen kallas tillståndsrum (state space) l Hörnen kallas tillstånd

2 0/1 heltals-lp-problemet 5 Grafrepresentation av LP-problemet 6 l Minimera f(x) = c T x med bivillkoret Ax b A = , b = 25, c = dvs minimera f ( x ) = 2 x 1 + x 2 x x 4 under villkoren att 5 x x 2 + x x 4 8 x 1 x 2 x x x 1 + x 2 + x x Varje x i kan anta värdet 0 eller 1 totalt 16 olika värden för vektorn x - En del av dessa 16 värden uppfyller dock ej bivillkoren Ingen kombination med x 1 = 0 kan ge 5x 1 + 2x 2 + x 3 +2x 4 8 Endast två tillåtna lösningar: (1, 0, 1, 1) T och (1, 1, 0, 1) T varav den första ger minst f(x)-värde f(x) = -1 f(x) = 1 Heuristik 7 Sekventiella sökalgoritmer 8 l Ibland kan kostnaden från ett tillstånd x till ett måltillstånd uppskattas med ett heuristiskt estimat h(x) l Om h(x) är undre begränsning av kostnaden är h(x) admissible (sv. tillåtet) l Låt l(x) = g(x) + h(x) där g(x) är faktisk kostnad för att nå x l h(x) admissible l(x) undre gräns för totalkostnaden till mål via x Exempel: 8-pusslet l Avståndet mellan position (i, j) och (m, n) är i - m + j - n och kallas manhattanavståndet l Summan av alla brickors manhattanavstånd till deras positioner i lösningen är en skattning på avstånd till lösning (manhattanheuristik) l Avståndet en undre gräns manhattanheuristiken är admissible Expansion av en nod i ett träd leder till en outforskad del av sökrummet. Så är ej alltid fallet i en godtycklig graf. (Ex: i 8-pusslet kan ett tillstånd erhållas genom olika sekvenser av brickflyttningar) Vi tittar på sökalgoritmer för både träd och andra grafer

3 Djupet-först-sökning (DFS) 9 DFS-exempel: 8-pusslet 10 Simple backtracking l DFS med terminering vid första tillåtna lösningen (ej optimal lösning) Djupet-först branch-and-bound l Fortsätter även efter en lösning är funnen l Förkastar genomsökta sökvägar som ej kan ge bättre lösning l Hittar optimal lösning Iterativ fördjupning A * (IDA*) l Djupet-först till begränsat djup l Fortsätter ej om l(x) = g(x) + h(x) > K l Initialt är K = l(s), därefter uppdateras K iterativt med minsta l-värde för nod expanderad i tidigare iterationer l Hittar optimal lösning om h(x) är admissible Första tre stegen med simple backtracking DFS I verkligheten vill man nog inte expandera bakåt Prioritering: - upp - ner - vänster - höger H: nästa nod att expanderas Stackrepresentation av tillstånd (2 alternativ) 11 Söknings-overhead 12 Endast ej undersökta noder Ej undersökta noder och dess föräldranoder Alt. 2 nödvändigt då sekvensen av transformationer som leder från start- till målnoden är en del av lösn. på problemet Riktningen på stacken missvisande - normalt tvärtom! l W = mängden arbete som utförs av den sekventiella algoritmen l W p = mängden arbete som utförs av den parallella algoritmen Söknings-overhead-faktorn är W p /W l Denna faktor inkluderar ej vanlig parallell-oh som t ex kommunikation, väntetider etc l Ger ett mått på hur mycket mer (eller mindre) arbete som den parallella algoritmer utför i jämförelse med den seriella l Medelvärdet av W p /W < 1 implicerar seriella algoritmen inte optimal (den parallella alg. + simulering av en parallellmaskin mha time-slicing vore snabbare!)

4 Statisk lastbalansering för DFS-agoritmer 13 Dynamisk lastbalansering för DFS-algoritmer 14 Kan ej på förhand avgöra storlek på underliggande träd 2 proc 4 proc Har jobb att fördela Kontrollera regelbundet om någon frågat efter jobb Vem ska skicka till vem? Vad ska skickas? Fråga efter jobb tills något erhålls Har inget jobb att fördela Algoritmer för att dela arbete mellan 2 proc 15 Dynamisk lastbalansering 16 l Arbetslös processor får hälften av annan processors arbete l Svårt att avgöra arbetsmängden i icke expanderad nod i stacken l Noder nära stackens botten (nära startnoden) expanderas ofta till större delträd än noder nära toppen l För att inte skicka för små arbetsmängder skickas ej noder ovanför en viss gräns i stacken ( cutoff depth ) Tre alternativ Skicka noder nära botten på stacken - Bra för uniformt sökrum. Låg kostnad. Skicka noder nära cutoff depth - Bra om heuristik finns. (Fördelar noder med störst chans till lösning.) Skicka hälften av noderna mellan botten och cutoff depth - Bra för irreguljärt sökrum Asynkron round robin l Varje processor har en lokal variabel target initierad till processorns eget id. l Då processor behöver arbete ökas target med 1 (modulo p) och förfrågan skickas till processor med id = target Flera kan samtidigt fråga samma processor Global round robin l En global target som hålls av en processor Flaskhals Slumpmässigt val (random polling) l Varje gång en processor behöver arbete skickar den en förfrågan till en slumpvis vald processor Obegränsad i värsta fallet

5 T o för parallella DFS-algoritmer 17 V(p) för olika lastbalanseringsalgoritmer 18 l Antag att arbete mindre än ε ej delas ett arbete w i kan delas i två delar w j och w k så att det existerar en konstant α sådan att w j > αw i och w k > αw i (om två processorer har delat ett arbete har ingen av dem mer än (1 - α)w i arbete) l Definiera V(p) som den mängd arbetsförfrågningar som krävs för att alla skall ha fått minst en förfrågan (sum. alla proc.) l Efter V(p) förfrågningar har ingen mer än (1 - α)w arbete. Efter 2V(p) förfrågningar har ingen mer än (1 - α) 2 W arbete l Efter (log 1/(1-α) (W/ ε)) V(p) förfrågningar är allas arbete mindre än ε l Totalt är antalat förfrågningar O(V(p) log W) l Om t comm är genomsnittlig tid för att skicka arbete så är T o = t comm V(p) log W E = 1/(1+T o /W) = 1/(1+(t comm V(p) log W/W) Kan bli riktigt bra om W stort! Asynkron round robin (i värsta fallet) l Antag att P p-1 har allt arbete och alla andra har target satt till P 0. För att proc p-1 ska få förfrågan måste någon ha skickat till p-1 processorer Samtidigt kan p-2 övriga hinna skicka p-2 förfrågningar vardera Övre gräns för V(p) = (p-1)+(p-2)(p-2) = O(p 2 ) Global round robin l V(p) = p (eftersom alla frågas i turordning) Slumpmässigt val (random polling) l Värsta fallet saknar gräns l Genomsnittlig V(p) kan härledas till p (1 + 1/2 + 1/ /p) = p H p där H p är ungefär 1.69 ln p för stora p V(p) = O(p log p) Isoeffektivitetsanalys för hyperkub 19 Isoeffektivitetsanalys för hyperkub (forts) 20 l Genomsnittliga avståndet mellan två noder är θ(log p) asymptotiskt värde för tcomm = θ(log p) T o = O(V(p) log p log W) (*) l Balansera T o mot W för varje lastbalanseringsstrategi Asynkron round robin l V(p) = O(p 2 ) (från tidigare analys) insatt i (*): T o = O(p 2 log p log W) W = O(p 2 log 2 p + p 2 log p log log p + p 2 log p log log W) l Isoeffektivitetsfunktionen (= dominerande termen) O(p 2 log 2 p) Global round robin l V(p) = θ(p) ger To = O(p log p log W) med W = O(p log 2 p) som dominerande term (m a p kommunikation) l Isoeffektivitet m a p databeroende för target : Variablen accessas O(p log W) gånger Vid effektivt proc-utnyttjande är exekveringstiden θ(w/p) När p ökas minskas effektiviteten men antalet accesser till target ökas. Det avhjälps genom att skala W så att W/p = θ(p log W) W = θ(p 2 log p) l Den totala isoeffektiviteten är alltså θ(p 2 log p) Slumpmässigt val (random polling) l V(p) = θ(p log p) ger T o = O(p log 2 p log W) W = O(p log 3 p)

6 Experimentella resultat: DFS uppsnabbning 21 DFS: Experimentell/beräknat antal förfrågningar 22 Genomsnitt för 30 problem med till 10 miljoner noder på NCUBE NCUBE 1024 proc hyperkub Genomsnitt för 30 problem med till 10 miljoner noder på NCUBE DFS: Experimentella isoeffektivitetskurvor 23 Parallell djupet-först branch and bound 24 Genomsnitt för 30 problem med till 10 miljoner noder på NCUBE l Vanliga parallella djupet-först måste modifieras så att alla processorer vet vilken som är den aktuella bästa lösningen (för att kunna avgöra om ett delträd kan vara lönsamt att expanderas eller ej) Gemensamt minne l Global datastruktur innehåller aktuella bästa lösning som varje processor jämför med Distribuerat minne l Varje processor som hittar en lösning bättre än aktuell bästa gör broadcast på sin lösning till alla andra

7 Parallell iterativ fördjupning A* 25 Att upptäcka terminering 26 Alternativ 1 l Olika processorer undersöker olika delar av trädet med sekventiell A* l Nackdelar: Oklart hur gräns för l(x)-värde skall väljas för varje processor Kan eventuellt missa att ge optimal lösning l Antag att varje processor i en ring ej får mer jobb då den blir klar l Då P 0 blir klar skickar den ett klartecken till P 1 l Då P i blir klar och har fått klartecken från P i-1 skickar den ett klartecken till P i+1 Alternativ 2 l Alla processorer använder samma l(x)-värde l Efter varje iteration avgör en utvald processor vilken gräns som skall användas nästa iteration l Kräver kommunikation till och från denna processor mellan varje iteration Fungerar bra om processor som skickat klartecken ej kan få mer arbete senare Dijkstras algoritm för att upptäcka terminering 27 Trädbaserad alg. för att upptäcka terminering 28 1 Då P 0 blir klar skickar den vit flagga till P 1 och markerar sig själv som vit 2 Om processor P i skickar jobb till P j och i > j blir processor i svart 3 Om P i får flagga från P i-1 och P i är utan jobb så skickar den vidare flaggan till P i+1.om P i är svart sätter den flaggan till svart innnan den skickar den vidare. 4 Efter P i skickat flaggan till P i+1 markerar den sig själv som vit 5 När P 0 får tillbaka vit token kan processerna terminera l P 0 har startnod för problemet och en vikt w = 1 l Varje gång någon processor delar med sig hälften av sitt arbete halveras även vikten (skickar med halva) l Då processor blir klar returneras vikten l Alla processorer är klara då P 0 åter har w = 1 l Numeriska problem: pga den ändliga talrepresentationen riskerar de små tal som uppstår då w delas tillräckligt många gånger att ge stora fel (eller t.o.m. försvinna)

8 Exempel: trädbaserad algoritm 29 Bäst-först-sökning 30 l Både för träd och generella grafer l En öppen-lista för genererade men ej expanderade noder, sorterad efter heuristik om troligaste kandidat för att hitta lösning l En stängd-lista för expanderade noder A * l Använder heuristikfunktion så att l(x) = undre gräns för kostnad l Finner optimal lösning Nackdel med bäst-först-algoritmer l Minnesåtgång beror linjärt av storleken på den undersökta delen av sökrummet Bäst-först: 8-pusslet 31 Parallella bäst-först-algoritmer 32 Manhattanavstånd Starttillstånd Måltillstånd Nästa att expanderas Nästa att expanderas Centraliserad öppen-lista l Undersöker alltid de p bästa noderna i listan l Kan dock undersöka noder som aldrig skulle undersökts av den sekventiella algoritmen l Termineringskriterium måste modifieras: Om en processor finner en till synes optimal lösning måste den vänta tills de andra p-1 processorernas samtida sökningar är klara för att se om de kan ha funnit bättre lösningar (kan expanderas hur mycket som helst ) l Öppen-listan måste kunna nås av alla processorer sekventiell flaskhals

9 Hantering av centraliserad öppen-lista 33 Distribuerade öppen-listor 34 P översta undersöks Strategier för att undvika för mycket sökande i dåliga områden: l Slumpmässig: Varje processor skickar regelbundet en delmängd av dess bästa noder till en slumpmässigt vald processor (Lite sök-oh om meddelande skickas ofta) l Ring: Varje processor utbyter regelbundet en delmängd av dess bästa noder med en av dess grannar i en ring (Hög sök-oh, dvs jämnar långsamt ut snedfördelning) (Passar nätverk med stor diameter) l Anslagstavla (blackboard): Expanderar endast noder från lokal lista som är inom viss tolerans från bästa på en global anslagstavla Om utvald nod är mycket bättre än bästa på anslagstavlan skickas några noder dit. Om utvald nod är mycket sämre än bästa nod hämtas några nya noder från anslagstavlan (Passar gemensamt minne) Ring 35 Anslagtavla 36

10 Avvikelser i uppsnabbning 37 Analys av genomsnittlig uppsnabbning i DFS 38 Genomsnittligt värde på söknings-oh Antaganden: l trädet har totalt M löv där vart och ett med sannolikhet ρ << 1 (med Bernoulli distribution) är lösning l Varje processor får en M/p-del av trädet l Saknar information om vilken ordning trädet bör genomsökas i l Totala antalet noder expanderade av p processorer är W p (W av sekventiell algoritm) Analys av söknings-oh 39 Analys av söknings-oh (forts) 40 Låt tätheten av lösningar i processor P i :s delträd vara ρ i Teorem Om ρ är tätheten i ett område måste i genomsnitt 1/ρ löv genomsökas innan lösning hittas l Detta är ekvivalent med att l W = 1/aritmetiska medelv. av (ρ 1 + ρ ρ p ) l Wp = 1/harmoniska medelv. av (ρ 1 + ρ ρ p ) P = 1:Antal löv som genomsöks är i genomsnitt W 1 p ( ) ρ 1 ρ 2 ρ p om lösning i varje delträd P > 1: Sannolikhet för att hitta lösning är i varje steg (för varje expanderad nod) p 1 (1 ρ i ) ρ 1 + ρ ρ p vilket ger i = 1 p W p ρ 1 + ρ ρ p l Eftersom AM HM är W W p : l Om ρ 1 = ρ 2 =... = ρ p är AM = HM och W ~= Wp l Om ρ i är olika för olika i är AM > HM och W > Wp

11 Parallella DFS-algoritmer på SIMD 41 När skall lasten balanseras på SIMD 42 l MIMD-algoritmerna ger 2 problem på SIMD Eftersom alla processorer samtidigt gör samma sak kan inte en processor expandera en nod samtidigt som en annan t.ex. gör back tracking l löses genom villkorssatser. Detta ger dock sämre processorutnyttjande (P0 expanderar och P1 väntar, P0 väntar och P1 gör back tracking ) Lastbalansering måste göras globalt ett fåtal processorer utan arbete kan ej exekvera lastbalanseringsalgoritmer medan andra processorer utför annat arbete l En sökningsfas och en lastbalanseringsfas l 1 processor som blir utan arbete måste vänta till nästa lastbalanseringsfas innan den kan få arbete igen l Krititiska komponenter: Mekanism för att avgöra när lastbalansering skall göras Själva lastbalanseringsalgoritmen l För sällan för mycket väntetider l För ofta onyttigt arbete tar för mycket tid l Statisk bedömning l Förhållandet mellan processorer utan jobb och processorer med jobb går över en förutbestämd gräns l Dynamisk bedömning l Balanserar totala väntetiden mot tiden nästa lastbalansering tar för varje processor: l widle = totala tiden alla processorer har väntat sedan förra lastbalanseringsfasen l tl= totala tiden nästa lastbalanseringsfas tar för varje processor l Lastbalansering görs då widle p tl Hur lasten skall balanseras på SIMD 43 Varje processor utan arbete måste paras ihop med en som har arbete att fördela