Vi har presenterat en låg komplexitet schemaläggning algoritm med prestanda jämförbar eller ännu bättre i genomsnitt till mycket högre komplexitet heuristik. Den låga komplexiteten gör DSC mycket attraktivt i praktiken. DSC kan användas i det första steget i Sarkars [17] tvåstegsmetod för schemaläggning på ett begränsat antal processorer. Vi har redan införlivat DSC i vår programmeringsmiljö PYRROS [23] som har gett mycket goda resultat på verkliga arkitekturer som NCUBE-II och INTEL/i860. DSC är också användbar 31 kommunikationskant vid varje steg, det kan få den största minskningen tidigare. Detta är inte fallet för de andra undergrupperna eftersom sedan storleken på grafer är större och DSC ges fler möjligheter (steg) till noll kanter. Tabell 5: DSC mot ETF och Sarkars för grupp M2. R/C varierar mellan 0,1 och 0,3. Finkorniga DAGs En sammanfattning av experimenten för 180 slumpmässiga DAGs ges i tabell 6. Vi listar andelen fall när prestanda DSC är bättre, samma, och värre än de andra två algoritmer. Detta experiment visar att DSC:s genomsnittliga prestanda är bättre än Sarkars och är något bättre än ETF:s. För att se dierences i komplexiteten mellan DSC och ETF och visa praktiska DSC, anser vi en viktig DAG i numeriska datorer, Choleski decomposition (CD) DAG, Cosnard et al. [8]........................................ För en matris storlek n graden av parallellism är n, antalet uppgifter v är ungefär n 2 = 2 och uppgifterna, vi förväntar oss en liknande prestanda från båda metoderna. ETF, DSC och Sarkar bygger å andra sidan på olika principer och det är av intresse att göra en experimentell jämförelse av dessa tre metoder. Vi har genererat 180 slumpmässiga DAGs enligt följande: Vi rst slumpmässigt generera antalet lager i varje DAG. Vi placerar sedan slumpmässigt ett antal oberoende uppgifter i varje lager. Därefter kopplar vi slumpvis ihop kanterna mellan uppgifterna på olika lager. Slutligen tilldelar vi slumpmässiga värden till uppgifts- och kantvikter. Följande statistikinformation är viktig för att analysera prestandan hos schemaläggningsalgoritmer: W: Utbudet av oberoende uppgifter i varje lager. Den är ungefär lika stor som den genomsnittliga graden av parallellism. L: Antalet lager. R/C: Det genomsnittliga förhållandet mellan arbetsvikter över kantvikter. Den är ungefär lika stor som grafens granularitet. De 180 graferna är indelade i tre grupper om 60 grafer vardera baserat på deras R/C-värden. R/C-intervallet är 0,8–1,2. Den genomsnittliga vikten av beräkning och kommunikation är nära. M2: R/C intervallet är 3-10. Graferna är grova korn. M3: R/C intervallet är 0,1-0,3. Graferna är ne korn. Varje grupp klassificeras ytterligare i 6 undergrupper med 10 grafer vardera, baserat på värdena för W och L. Resultaten av schemaläggning grupp M1, M2 och M3 sammanfattas i tabell 3, 4 och 5. De fth och sjätte kolumnerna i tabellerna visar den parallella tidsförbättring förhållandet mellan DSC över ETF och Sarkar algoritm. Förbättringsförhållandet för DSC över algoritm A är dened som DSC=A = 1 0 P T dsc P T A : För grupp M1, DSC/ETF visar en förbättring med 3% och DSC/Sarkar med 20%. För den grova korngruppen M2 är prestandaskillnaderna obetydliga mellan ETF och DSC och små mellan Sarkars och DSC. För ne korngruppen M3 liknar prestandan M1 utom i den första undergruppen där Sarkars presterar bäst. Detta beror på att för denna grupp graden av parallellism och antalet lager är små och granulariteten är relativt ne. Detta innebär att kommunikationen dominerar beräkningen och eftersom Sarkars algoritm minskar kommunikationsvolymen genom att nollställa den största 29 är uppgiften med den högsta blevel planerad och denna heuristic kallas ETF/CP i [12]. ETF är utformad för schemaläggning på ett begränsat antal processorer. Således för att jämföra prestanda DSC och ETF vi rst tillämpa DSC för att bestämma antalet processorer (kluster), som vi sedan använder som en ingång till ETF algoritm. Vi diskuterar DSC:s och ETF:s olikheter och likheter enligt följande. För en nodprioriterad DSC använder tlevel + blevel, och väljer sedan den största nodprioriteringen. Å andra sidan använder stiftelsen den tidigaste uppgiften som liknar att använda tlevel som nodprioritering och sedan välja den minsta nodprioriteringen för schemaläggning. För schemaläggning steg DSC och ETF använder samma idé, dvs.. Försök att minska tnivå genom att schemalägga till en processor som kan starta en uppgift så tidigt som möjligt. Men tekniken för att välja en processor är olika. ETF placerar en uppgift till processorn som tillåter den tidigaste starttiden utan att schemalägga om sina föregångare, medan DSC använder minimeringsförfarandet som skulle kunna schemalägga om några av föregångarena. Det bör nämnas att MCP [19]-algoritmen också schemalägger en uppgift för en processor som tillåter dess tidigaste starttid som i ETF. Nodprioriteringen för MCP är dock bleve jämfört med t-nivå som används av ETF. ETF:s komplexitet är högre än DSC. Eftersom ETF vid varje steg undersöker alla fria uppgifter på alla möjliga processorer till nd den minsta starttiden, komplexiteten hos ETF är O (pw) där p är antalet processorer som används, w är den maximala storleken på den fria aktivitetslistan. För v uppgifter är den totala komplexiteten O(pwv). ).............................................................................................. Vi har använt den balanserade sökträd struktur för ETF algoritm i nding värdena för en klocka variabel, NM, [12], pp. Tvåhundratvåhundrafemtiofem. ETF:s komplexitet när det gäller den tidigaste uppgiften vid varje steg kan dock inte minskas, eftersom den tidigaste starttiden för en uppgift beror på var processorer ska placeras som ska tilldelas. I praktiken kan stiftelsens genomsnittliga komplexitet vara lägre än O(v3). För Choleski nedbrytning DAG beskrivs i avsnitt 6.3, p = O( p v) och w = O( p v), alltså är den faktiska komplexiteten O( v 2 ). I avsnitt 6.3 jämför vi CPU-tiden för DSC och ETF på en SUN 4 arbetsstation. För en anslutning DAG, ETF använder inte en minimering förfarande som DSC, och det kanske inte är optimal. För en gaffel, ETF kan plocka upp en uppgift med den tidigaste starttiden, men denna uppgift kanske inte är i en DS och därmed ETF kanske inte ger den optimala. För en grov säd i träd, sätter ETF en uppgift till processor av sin efterträdare som ger den tidigaste starttiden för denna uppgift. Vi kan använda ett liknande tillvägagångssätt som i DSC för att bevisa optimaliteten av ETF för grova korn i träd. En sammanfattning av jämförelsen beskrivs i tabell 2. Lägg märke till likheterna och skillnaderna mellan MCP och ETF och mellan MD och DSC. För en detaljerad jämförelse mellan MCP och DSC, se [10]. På grund av NP-fullbordandet av detta schemaläggningsproblem kan heuristiska idéer som används i DSC inte alltid leda till en optimal lösning. Således är det nödvändigt att jämföra den genomsnittliga prestandan för olika algoritmer med hjälp av slumpmässigt genererade grafer. Eftersom både MD och DSC använder DS för att identifiera den viktiga 28 nishing tiden, T F (n i ). Den relativa rörligheten för en nod är dened av (T L (n i ) 0 T S (n i )) = w(n i ) där w(n i) är uppgiften vikt. MCP-algoritmen använder T L (n i ) som en nodprioritering. Den väljer sedan den fria noden med minsta nodprioritet, vilket motsvarar att välja noden med den största blevel(n i ), och schemalägger den till en processor som tillåter dess tidigaste starttid. MD-algoritmen använder den relativa mobiliteten som en nodprioritering och vid varje steg i schemaläggningen identifierar den en uppgift n p med hjälp av den minsta relativa mobiliteten. Den undersöker sedan tillgängliga processorer från och med P E 0 och schemalägger n p till den första processorn som tillfredsställer ett tillstånd som kallas Fact 1 [19], s. 336 4............................................................... En intuitiv förklaring till Fact 1 är att schemaläggning av en uppgift n p till en processor m inte bör öka längden på den aktuella kritiska vägen (DS). Komplexiteten i den ursprungliga algoritmen är O(v 3 ) som visas i [19], pp. - Jag vet inte. 337. Den korrigerade versionen av MD har en bättre prestanda men något högre komplexitet. Detta beror på omräkning av T S och T F för varje skannad processor. För varje schemaläggningssteg är komplexiteten hos MD O(p(v + e)) där p är antalet skannade processorer och O(v + e) för mobilitetsinformation och kontroll Fact 1 för varje processor, och eftersom det finns v steg är den totala komplexiteten för den reviderade MD O(pv(v + e)). Idén att identifiera de viktiga uppgifterna i DSC är densamma som i MD, dvs.. De minsta relativa rörlighetsidentiteterna DS-noder som har den maximala t-nivån + b-nivån. Men sättet att identifiera DS noder är olika. DSC använder en prioriterad funktion med ett O(log v) datorsystem, medan MD använder den relativa mobilitetsfunktionen med en datorkostnad på O(v + e). En annan dierence är att när DSC väljer en DS-uppgift n p att schemalägga, det använder minimeringsförfarandet för att minska tnivå av denna uppgift och därmed minska längden på DS som går igenom denna uppgift. Å andra sidan, MD skannar processorer från vänster till höger till ND rst processorn tillfredsställande Fact 1. Även om Fact 1 garanterar att den nuvarande kritiska vägen inte ökar, behöver den inte nödvändigtvis göra stiglängden kortare. För en gaffel eller gå, MD plockar upp DS noden vid varje steg och vi kan visa att det producerar en optimal lösning. För ett grovt sädesträd, som vi såg i vårt optimala bevis, måste t-nivån minskas vid varje steg. Eftersom MD schemalägger en uppgift till en processor som inte nödvändigtvis minskar t-nivån vid varje steg, MD kanske inte producerar den optimala i allmänhet. En sammanfattning av denna jämförelse finns i tabell 2. 6.2 ETF-algoritm ETF [12] är en schemaläggningsalgoritm för ett begränsat antal processorer med godtyckliga nätverkstopologier. Vid varje schemaläggning steg, ETF nds en fri uppgift vars starttid är den minsta och sedan tilldelar denna uppgift till en processor där uppgiften utförande kan startas så tidigt som möjligt. Om det finns en slips sedan 4 I en nyligen personlig kommunikation [20], författarna har gjort följande korrigeringar till MD algoritm presenteras i [19] : (1) För fakta 1 när man överväger processor m, bör villkoret \ för varje k " ändra till \det finns k", [19], pp. - Jag vet inte. (2) Beräkningen av TF och TS [19], s. 336, bör anta att aktiviteten np är schemalagd på processorn m. (3) När np är schemalagd till processorn m, np infogas innan den första uppgiften i aktivitetssekvensen av processorn m som mättar den ojämlikhet som anges i Fact 1. och har prioritet 3w + c. Således från steg 2 till steg q + 1, alla q noder i T k undersöks en efter en. Efter steg q + 1, DSC tittar på n 2 ; n 3 ; 1 11; n j. Eftersom från steg 2 till q+1, DSC kluster T k endast, DSC får en optimal klusterlösning för detta delträd genom induktionshypotesen. Vi kallar parallelltiden för detta underträd P T opt (T k ). Därefter är den parallella tiden efter steg q + 1: P T q+1 dsc = max(w + P T opt (T k ); 2w + c): Låt P T dsc vara tiden efter det nationella steget av DSC för T k+1. Vi studerar följande två fall: (1) En kant i T k är inte nollad av DSC. Därefter P T opt (T k ) 2w + c innebär P T q+1 dsc = w + P T opt (T k ): Låt P T dsc vara tiden för det nationella steget, eftersom den stegvisa parallella tiden för DSC monotoniskt minskar, P T q+1 dsc P T dsc. Även eftersom den optimala parallella tiden för en graf inte bör vara mindre än den för dess subgraf, P T opt (T k+1 ) w + P T opt (T k ). Således P T dsc P T opt (T k+1 ) och DSC är optimal för detta fall. kan betraktas som kluster av en gaffel med \leaf-node" n 1 med en vikt qw. Eftersom DSC är optimalt för en gaffel, DSC kommer att få den optimala för T k+1. Slutligen undersöker vi fallet att n 0 endast har en efterträdare, dvs. j = 1. DSC rst nollor kant (n 0 ; n 1 ) sedan får den optimala för T Det finns många kluster algoritmer för allmänna DAGs, t.ex. Sarkar [17], Kim och Browne [13] och Wu och Gajski [19]. En jämförelse av dessa algoritmer ges i Gerasoulis och Yang [10]. I detta avsnitt jämför vi DSC med MD-algoritmen för Wu och Gajski [19] och ETF av Hwang, Chow, Anger och Lee [12]. Vi erbjuder också en experimentell jämförelse för ETF, DSC och Sarkars algoritmer. Wu och Gajskis [19] har föreslagit två algoritmer MCP och MD. Vi hänvisar läsaren till [19] för beskrivning av både algoritmer och de termer som används i denna punkt. Författarna använder begreppet as-soon-as-opable (ASAP) starttid T S (n i ) och as-late-as-opable (ALAP) time T L (n i ) och senaste MD-algoritmen Finkorniga träd Att hitta optimala lösningar för allmänna ne kornträd är NP-komplett. DSC kan dock få ut optimalt för en klass av ne kornträd. En single-pawn out-tree är ett ut träd sådan att som mest en efterträdare till en icke-leaf träd nod, säger n x, kan ge upphov till efterträdare. Andra efterträdare till n x är blad noder. Ett enda träslag är ett omvänt av ett enda träd. Exempel på sådana träd visas i bild. 10................................................................ Teorem 5.6 Med tanke på att det finns ett enda träd eller ett enda träd med samma beräkningsvikt w för varje uppgift och en lika stor kommunikationsvikt c för varje kant, är DSC optimalt för detta träd. Bevis: Vi kommer att lägga fram ett bevis för ett yttre träd genom induktion på höjden (h) av detta träd. Bevisen för ett träd är likartade. När h = 2, är det en gaffel och DSC är optimal. Antar att DSC får den optimala när h = k. När h = k + 1, antar vi utan förlust av generalitet att efterträdare till rot n 0 är n 1 ; n 2 ; 1 11; n j och att n 1 leker efterträdare. Först antar vi att n 0 har fler än 1 efterträdare, dvs. j > 1. Bilda. 11 avbildar detta träd. Vi kallar hela trädet T k+1 och underträdet rotat i n 1 T k. Höjden på T k är k och det har q uppgifter där q > 1. Vi hävdar att DSC kommer att undersöka alla noder i underträdet T k rst innan de undersöker andra efterträdare till n 0. I steg 1, n 0 undersöks och alla efterträdare till n 0 blir fria. Node n 1 har prioritet P RIO(n 1 ) 3w + 2c och andra efterträdare till n 0 har prioritet 2w + c. Då n 1 granskas i steg 2, (n 0 ; n 1 ) är noll och alla efterträdare till n 1 läggs till i den fria listan. Prioriteringen av n 1 efterträdare 3w + c. Således kommer de att undersökas före n 2 ; 1 11; n j. Recursively, alla n 1 ättlingar kommer att befrias 25 Theorem 5.5 DSC ger en optimal lösning för en grov säd i träd. Bevis: Eftersom alla vägar i ett träd går genom trädroten, säger n x, P T = tlevel(n x ) + blevel(n x ) = tlevel(n x ) + x. Vi hävdar att tlevel (n x ) minimeras av DSC. Vi bevisar det genom induktion på djupet av trädet (d). När d = 0, är det trivialt. När d = 1, är det en gå DAG och tlevel (n x ) minimeras. Anta att det är sant för d < k. När d = k, låt föregångaren till roten n x vara n 1 ; 11 1; n m. Eftersom varje delträd rotat med n i har djup < k och de delade subgraferna inte kan klumpas ihop av DSC, DSC kommer att få den minsta tleveltiden för varje n j där 1 j m enligt induktionshypotesen. När n x blir fri, tlevel(n x ) = max 1jm fCT(n j )+c j;x g; CT (n j ) = tlevel(n j )+ j. Utan förlust av allmängiltighet, anta att (n 1 ; n x ) är i en DS och t nivå (n 1 ) + 1 + c 1;x har det högsta värdet och t nivå (n 2 ) + 2 + c 2;x har det näst högsta värdet. DSC kommer att noll (n 1 ; n x ), och tlevel(n x ) = max (CT (n 1 ); max 2jm fCT(n j )+ c j;x g): (DSC kommer inte noll längre kanter på grund av grov korn tillstånd. DSC kan vara noll (n 2 ; n x ) när g( G) = 1, men tlevel(n x ) inte minskar.) Vi måste bevisa att tlevel (n x ) är den minsta möjliga. Eftersom trädet är grovkornigt kan linjär klustring med Teorem 5.1 användas för att härleda den optimala lösningen. Således kan vi anta att S 3 är ett optimalt schema som använder linjär klustring. Låt tlevel 3 (n j ) vara tlevelvärdet för n j i schema S 3, och CT 3 (n j ) = tlevel 3 (n j ) + j, CT 3 (n j ) CT ( n j ) för 1 j m från antagandet att CT (n j ) är minimum. Nu ska vi visa att tlevel 3 (n x ) tlevel(n x ). Det finns två fall: (1) Om i S 3 den nollade inkommande kanten av n x är (n 1 ; n x ), sedan tlevel 3 (n x ) = max (CT 3 (n 1 ); max 2jm fCT 3 (n j ) + c j;x g) max (CT (n 1 ); max 2jm fCT(n j ) + c j;x g) = tlevel(n x ): (2) Om i S 3 den nollade inkommande kanten av n x är inte (n 1 ; n x ), säg att det är (n m ; n x ). Således tlevel 3 (n x ) = max (CT 3 (n m ); max För en out-tree, kan vi alltid vända denna DAG och använda DSC för att schemalägga den inverterade grafen. Då kan den optimala lösningen erhållas. Vi kallar detta tillvägagångssätt den bakåtdominerande sekvensen klusterering Efter n x undersöks, DSC kommer att undersöka fria noder n 1 ; n 2 ; 1 11; n m i en fallande ordning av deras prioriteringar. Prioritetsvärdet för varje fri nod är längden på varje stig < n x ; n 1 >, 1 1 1, < n x ; n m >. Om vi antar att k + k+1 + k+1 för 1 k m 0 1, då noderna sorteras som n 1, n 2 ; 1 11; n m i den fria listan F L. Vi rst bestämma den optimala tiden för gaffeln och sedan visa att DSC uppnår den optimala. Anta den optimala parallella tiden att vara P T opt. Om P RIO(n h ) = x + h + h > P T väljer några h, då måste jag ha nollat för i = 1 : h, annars har vi en motsägelse. Alla andra kanter i > h behöver inte nollställas eftersom nollställning av sådana kanter inte minskar P T utan kan öka P T. Låt den optimala stopppunkten för nollställning vara h och anta att m+1 = m+1 = 0. Då är den optimala P T: P T opt = x +max( P k01 j=1 j k och P k j=1 j > k+1. Vi kommer att bevisa att P T opt = P T dsc genom motsägelse. Antag att k 6 = h och P T opt < P T dsc. Det finns två fall: (2) Om h > k, sedan P h j=1 j P k+1 j=1 j > k+1 + k+1 h+1 + h+1, har vi att P T opt = x + P h j=1 j x + max( P k j=1 j ; k+1 + k+1 ) = P T dsc : Det finns en motsägelse i båda fallen. För en förening använder DSC minimeringsförfarandet för att minimera rotens tlevelvärde och lösningen är symmetrisk till det optimala resultatet för en gaffel.  Ett träd är ett riktat träd där roten har utgående grad noll och andra noder har utgående grad ett. Ett out-tree är ett riktat träd där roten har inkommande grad noll och andra noder har inkommande grad ett. Schemaläggning i/ut träd är fortfarande NP-hård i allmänhet som visas av Chretienne [5] och DSC kommer inte att ge den optimala lösningen. DSC kommer dock att ge optimala lösningar för grova sädesträd och en klass av ne spannmålsträd. Grova sädesträd 23 5 Performance Bounds and Optimality of DSC I detta avsnitt studerar vi DS prestandaegenskaper. Vi ger en övre gräns för en general DAG och bevisar optimaliteten för gafflar, fogar, grova sädesträd och en klass av ne kornträd. Eftersom detta schemaläggningsproblem är NP-komplett för en allmän ne korn träd och för en DAG som är en konkatering av en gaffel och en anslutning (serie parallell DAG) [3, 5], analysen visar att DSC inte bara har en låg komplexitet utan också uppnår en optimal grad som en allmän polynom algoritm kan uppnå. En DAG består av gaffel (F x ) och / eller gå (J x ) strukturer såsom de som visas i Fig Theorem 5.2 Låt P T välja vara den optimala parallella tiden och P T lc vara den parallella tiden för en linjär klustering, ) P T välja : För en grov korn DAG, P T lc 2 2 P T välja : Följande teorem är en prestanda gräns DSC för en allmän DAG. Teorem 5.3 Låt P T dsc vara den parallella tiden av DSC för en DAG G, sedan )P T opt : För en grov korn DAG, P T dsc 2 2 P T opt : Bevis: I det första steget av DSC, alla noder är i de separata kluster, som är en linjär kluster. Av Theorem 5.2 och Theorem 4.2 har vi att P T dsc : :: P T k : : : P T 1 P T 0 (1 + 1 g (G) P T välja : För grov spannmål DAGs uttalandet är uppenbart. Antag att n r blir undersökt i steg j i + 1. I steg i + 1 måste alla DSs gå igenom (n r ; n s ). Om från i+1 till steg j parallelltiden har minskats så är teorem sant. Om parallelltiden inte har minskats så har åtminstone en DS inte komprimerats och alla DS går fortfarande igenom (n r ; n s ) eftersom minimeringsförfarandet garanterar att inga andra DS kommer att skapas. På så sätt blir parallelltiden reducerbar i steg j och bevisen blir desamma som i de ovan nämnda fallen. Följande följd är det direkta resultatet av fall 2 i ovanstående sats. Samband 4.3 Antag att n y 2 P F L, n y 2 DS i steg i och att nollställning av en inkommande kant av n y från en planerad föregångare skulle ha minskat PT med. Därefter garanterar DSC att när n y blir fri i steg j (j > i), PT kan minskas med minst. Komplexiteten Lemma 4.4 För varje nod n s i FL eller PFL, tlevel(n j ) för n j 2 P RED(n s ) T EG förblir konstant efter n j undersöks, och blevel(n s ) förblir konstant tills det undersöks. Bevis: Med hänvisning till Property 3.2 av DSC-I, DSC är samma som DSC-I förutom att minimeringsförfarandet ändrar tlevel värden för vissa undersökta föregångare, säger n h, av den för närvarande utvalda fria uppgiften, säger n x. Men en sådan förändring påverkar inte någon nod i F L eller P F L eftersom n h inte har andra barn än n x. Bevis: Dierencen i komplexiteten mellan DSC-I och DSC är ett resultat av minimeringsförfarandet inom When slingan i bild. 7............................................................ I DSC underhåller vi också PFL men kostnaden för v stegen är samma O(v log v) när vi använder balanserade sökträd. Därför, för rad 4 och 5 i bild. 7, v steg kostar O(v log v). För linje 7 och 8 (eller linje 9 och 10) kostar minimeringsförfarandet O(jP RED(n x )j log jPRED(n x )j) vid varje steg. Eftersom P nx 2V jPRED(n x )j = e och jPRED(n x )j < v, v steg kostar O(e log v). För linje 13 uppdateras t-nivåvärdena för efterträdare till n x. Dessa efterträdare kan vara i P F L och listan måste omrangeras eftersom deras pP RIO-värden kan ändras. Kostnaden för att justera varje efterträdare i P F L är O(log jPFLj) där jPFLj < v. Stegkostnaden för Linje 13 är O(jSUCC(n x )j log v). Eftersom P nx2V jSUCC(n x )j = e, är den totala kostnaden för att upprätthålla P F L under v steg O(e log v). Även för linje 13 när en efterträdare blir fri, det måste läggas till F L med kostnad O(log jFLj) där jFLj v. Eftersom det finns totalt v uppgift som kunde bli gratis under v steg, den totala kostnaden i linje 13 spenderas för F L under v steg är O(v log v). Observera att enligt lemma 4.4, efter att n x har flyttats till EG vid linje 13, kommer dess tlevelvärde inte att påverka prioriteringen av uppgifter i P F L och F L i resten av stegen. Uppdateringen av F L eller P F L sker således endast en gång för varje uppgift. Således är den totala tids komplexiteten O(e+v) log v. Utrymmet som behövs för DSC är att lagra DAG och F L=P F L. Utrymmets komplexitet är O(v + e). och n x är oberoende. Om det finns en ökning av prioritetsvärdet n e, Då anledningen måste vara att lägga till denna pseudo edge introducerar en ny väg som går igenom n x med längre längd jämfört med de andra befintliga vägar för n e. Eftersom minimering förfarandet har ansett eekten att fästa n x efter n e på tlevel (n x ), längden på stigar kommer att vara mindre än eller lika med P RIO(n x ; i 0 1) P T i01. Således P RIO(n e ; i) P T i01. På samma sätt kan vi bevisa att andra noder i CLUST (n e ) tillfredsställa denna ojämlikhet. Eftersom de prioriterade värdena för noder, säger n o, som inte är föregångare till n x eller inte i CLUST (n e ) inte kommer att acekteras av minimeringsförfarandet, har vi P RIO(n o ; i 0 1) = P RIO(n o ; i). Således max ne2EG S fnxg fPRIO(n e ; i)g P T i01. 2 Theorem 4.3 Efter steg i av DSC, om den aktuella parallella tiden är reducible genom att nollställa en inkommande kant av en nod i UEG, då DSC garanterar att den parallella tiden kommer att minskas vid något steg större eller lika med i + 1. Bevis: Antagandet att parallelltiden minskar med nollställning en kant (n r ; n s ), innebär att en DS måste gå igenom UEG. Detta innebär att kanten (n r ; n s) tillhör alla DS som går genom UEG, annars parallelltiden är inte reducible. Det finns tre fall: (1) n r 2 EG och n s är gratis. Vi bevisar att noden n s måste vara chefen för F L. Om det inte är, då en annan fri nod i UEG, n f, måste ha samma prioritet och därmed tillhör en DS. Eftersom alla DS går igenom (n r ; n s ), n f måste vara en föregångare till n s antyder att n s är partiellt fri vilket är en motsägelse. Även eftersom P T i = blevel(n s) + tlevel(n s) är reducible genom nollning (n r ; n s ), och blevel(n s ) inte förändras genom en sådan nollställning, då tlevel(n s ) är reducible. Således under DSC utförande, n s = head(F L) kommer att plockas upp i steg i + 1, och eftersom tlevel (n s ) är reducible minimization proceduren kommer att acceptera nollställning av (n r ; n s ) och den parallella tiden kommer att minska vid det steget. (2) n r 2 EG och n s är partiellt fria. Eftersom alla DS går igenom (n r; n s), inga fria noder är i DS och andra partiella fria noder, n f i DS måste vara efterträdare till n s. Således pP RIO(n s) = P RIO(n s) men pP RIO(n f) < P RIO(n f ). Eftersom P RIO(n f ) = P RIO(n s ) sedan pP RIO(n f ) < pP RIO(n s ) och n s måste vara chefen för P F L. Antag att P T i = blevel(n s ) + ptlevel(n s ) är reducible med > 0 när nollställning (n r ; n s ) och blevel(n s ) inte förändras genom en sådan nollställning. Då ptlevel (n s) är reducible med minst. Således, under genomförandet av DSC, kommer reducibiliteten av ptlevel (n s ) att upptäckas i steg i + 1. Efteråt nollställs icke-DS-kanterna tills n s blir fri. Dock är reducibiliteten av ptlevel (n s ) inte acekted av sådana nollor på grund av DSRW. En icke-DS nod förblir en icke-DS nod och inga andra noder flyttas till CLUST (n r ). När n s blir fri, ptlevel (n s ) är fortfarande reducible med minst Och eftersom andra SubDS antingen minska eller förbli oförändrad, då den parallella tiden är också reducible med minst. Resten av beviset blir detsamma som i det tidigare fallet. (3) n r 2 UEG. Lemma 4.3 Antag att n x = huvud(F L) och n y = huvud(P F L) efter steg i. Den parallella tiden för att utföra den klustererade grafen efter steg i DSC är: P T i = maxfP RIO(n x ); pP RIO(n y ); max ne 2EG fPRIO(n e )gg: Bevis: Det finns tre fall i beviset. (1) Om DS noder endast finns inom EG, sedan genom denition P T i = max ne2EG fPRIO(n e )g: (2) Om en DS går igenom en fri nod, sedan P T i = P RIO(n x ) av Lemma 4.1. (3) Om det finns en DS passerar genom UEG men denna DS endast passerar genom partiella fria noder, sedan P T i = P RIO(n y ) = pP RIO(n y ) av Lemma 4.2. Teorem 4.2 För varje steg i DSC, P T i01 P T i. Bevis: För detta bevis byter vi namn på de prioriterade värdena för n x = head(F L), och n y = head(P F L) efter steg i 0 1 som P RIO(n x ; i 0 1) och pP RIO(n y ; i 0 1) respektive. Vi måste bevisa, att P T i01 P T i, Där Vi bevisar rst att P RIO(n 3 Eftersom n 3 x är i den fria listan efter steg i 0 1, måste det vara i UEG och även det måste vara antingen efterträdaren till n x eller det är oberoende till n x. I steg i, DSC plockar upp uppgift n x för att undersöka dess inkommande kanter för nollställning. Vi anser eekten av sådan nollställning på prioritetsvärdet n 3 x. Eftersom minimeringsförfarandet inte ökar tlevel(n x ), längden på de vägar som går igenom n x minskar eller förblir oförändrad. Således kan prioritetsvärdena för ättlingar av n x minska men inte öka. Prioritetsvärdena för andra noder i EG förblir desamma eftersom minimeringsförfarandet utesluter de föregångare till n x som har andra barn än n x. Således om n 3 x är efterträdaren till n x, sedan P RIO(n 3 x ; i) P RIO(n 3 x ; i 0 1), annars P RIO(n 3 x ; i) = P RIO(n 3 x ; i 0 1). Sedan P RIO(n 3 x ; i 0 1) P T i01, sedan P RIO(n 3 x ; i) P T i01. På samma sätt kan vi bevisa att P RIO(n 3 y ; i) P T i01. Nästa vi bevisar att max ne 2EG S fnxg fPRIO(n e ; i)gg P T i01. Vi har P RIO(n x ; i) P RIO(n x ; i 0 1) från minimeringsförfarandet. Vi behöver bara undersöka eekten av nollställning för n x om prioriteringarna för noder i EG. Minimeringsförfarandet kan öka tlevel värdena för vissa föregångare av n x, säger n p, men det garanterar att längden på de vägar som går genom n p och n x inte ökar. Således det nya värdet av P RIO(n p ) mättar P RIO(n p ; i) P RIO(n x ; i 0 1). Sedan P RIO(n x ; i 0 1) P T i01, sedan P RIO(n p ; i) P T i01. Minimeringsförfarandet kan också öka blevelvärden för vissa noder i klustret i EG som n x är ansluten till. En pseudo kant läggs till från den sista noden av denna kluster, säger n e, till n x om n e 19 är i UEG, då måste det vara fritt som är omöjligt eftersom antagandet säger att DSs bara gå igenom partiella fria noder i UEG. På så sätt måste startnoden vara i EG. Som ett resultat en DS måste starta från en nod i EG och gå igenom en undersökt nod n j till dess oprövade partiella fri efterträdare n p. Sedan eftersom de är i samma DS har vi att P RIO(n p ) = P RIO(n j ) = pP RIO(n p ). Beviset påminner nu om den tidigare Lemma. Antag att ingen DS går igenom n y. Vi har den pP RIO(n y ) P RIO(n y ) < P T i = P RIO(n p ) = pP RIO(n p ) som motsäger antagandet att n y är chef för P F L. Nästa vi bevisar att pP RIO(n y ) = P RIO(n y ). Antag att pP RIO(n y ) < P RIO(n y ). Detta innebär att DS, där n y tillhör, inte passerar genom någon undersökt omedelbar föregångare n y. Som ett resultat DS måste gå igenom några andra noder i UEG. Således finns det en förfader nod n a av n y, sådan att DS passerar genom en kant (n q ; n a ) där n q är den undersökta föregångaren n a och n a är partiellt fri eftersom det är omöjligt att vara fri genom antagandena i denna Lemma. Vi har den pP RIO(n a ) = P RIO(n a ) = P RIO(n y ) > pP RIO(n y ) som visar n y är inte chefen för P F L. Detta är en motsägelse. Följande teorem visar att villkoret P RIO(n x ) pP RIO(n y ) som används av DSC algoritm i linje 6 i bild. 7 ), korrekt identifierar DS noder. Teorem 4.1 Antag att n x = head(F L) och n y = head(P F L) efter steg i och att det finns en DS går genom UEG. Om P RIO(n x ) pP RIO(n y ) sedan en DS går igenom n x. Om P RIO(n x ) < pP RIO(n y ), då DS det går igenom n y och också inte går igenom någon fri nod i F L. Bevis: Om P RIO(n x ) pP RIO(n y ), då kommer vi att visa att DS går igenom n x. Först antar DS går igenom F L eller både F L och P F L. Sedan enligt Lemma 4.1 det måste gå igenom n x. Nästa anta att DS går igenom endast P F L. Sedan från Lemma 4.2 det måste gå igenom n y, vilket innebär att pP RIO(n y ) = P RIO(n y ) = P T i > P RIO(n x ) vilket är en motsägelse eftersom P RIO(n x ) pP RIO(n y ). Om P RIO(n x ) < pP RIO(n y ), anta att en DS passerar en fri nod. Sedan enligt Lemma 4.1, P RIO(n x ) = P T i P RIO(n y ) pP RIO(n y ) som är en motsägelse igen. DS måste gå igenom partiella fria noder och en av dem måste gå igenom n y av Lemma 4.2. Garantin för att minska parallelltid I detta underavsnitt visar vi att om parallelltiden kan minskas vid något klustersteg så ser DSC-algoritmen till att parallelltiden minskas innan algoritmen avslutas. Den första Lemma ger ett uttryck för parallelltiden när det gäller prioriteringarna. Den andra Lemma visar att parallelltiden inte kan öka från ett steg till ett annat. Theorem bevisar att parallelltiden kommer att minskas om man vet att den är reducerbar. En följd av Theorem ger ett ännu starkare resultat för att minska parallelltiden. Om det kan påvisas att parallelltiden kan minskas med ett visst belopp i ett visst steg, garanterar DSC att minskningen av parallelltiden kommer att vara minst lika mycket som detta belopp. 18 t level(n 6 ) reduceras till 2,5 och UEG = fn 7 g P T 6 = 10 F L = fn 9+1 7 g P F L = fg (7), n 7 väljs och (n 2; n 7) nollställs så att tlevel(n 7 ) minskas från 9 till 7. Slutligen genereras tre kluster med P T = 8. I detta avsnitt studerar vi flera egenskaper hos DSC relaterade till identifiering av DS, minskning av parallelltiden och beräkningskomplex. Teorem 4.1 visar att DSC (linje 6 och 9 i bild). 7 ) korrekt lokaliserar DS noder vid varje steg även om vi använder partiell prioritet pP RIO. Teorem 4.2 och 4.3 visar hur DSC garanterar en minskning av parallelltiden. Teorem 4.4 ger upphov till komplexiteten. Den korrekthet i lokalisera DS noder Målet med DSC är att minska DS i en sekvens av steg. För att göra det måste den korrekt identifiera oprövade DS noder. I detta underavsnitt antar vi att en DS går igenom UEG, eftersom det är först då som DSC måste identifiera och komprimera DS. Om DS inte går genom UEG utan endast genom EG, då alla DS noder har undersökts och DS inte längre kan komprimeras eftersom backtracking är inte tillåtet. Eftersom DSC-algoritmen undersöker noderna topologiskt är den fria listan F L alltid icke-tom. Genom denition är alla uppgifter i F L och P F L i UEG. Det är uppenbart att en DS måste gå igenom uppgifter i antingen F L eller P F L, när det går igenom UEG. Den intressanta frågan är om en DS också går igenom cheferna för prioriteringslistorna för F L och P F L, sedan dess kommer prioriteringslistorna att korrekt identifiera DS noder som ska undersökas. Svaret ges i följande två Lemmas och Theorem. Lemma 4.1 Antag att n x = huvud(F L) efter steg i. Om det finns DS går genom fria noder i F L, då en DS måste gå igenom n x. Bevis: Vid slutförandet av steg i parallelltiden är P T i = P RIOR(n s ), där n s är en DS-nod. Anta att ingen DS går igenom n x. Då måste en DS gå igenom en annan non-head free node n f. Detta innebär att P RIO(n f ) = P T i > P RIO(n x ), vilket är en motsägelse eftersom n x har högsta prioritet i F L. Lemma 4.2 Antag att n y = head(P F L) efter steg i. Om DSs bara går igenom partiella fria noder i P F L, då en DS måste gå igenom n y. Dessutom pP RIO(n y ) = P RIO(n y ). Bevis: Observera först att startnoden för en DS måste vara en ingångsnod för denna DAG. Om denna nod Resultatet av DSC efter varje steg i schemaläggningen DAG visas i bild. 1 a............................................................... Vi demonstrerar DSC-stegen med hjälp av ett DAG-exempel som visas i bild. 1 a............................................................... Stegen 0, 1, 2, 5, 6 och 7 visas i bild. 9................................................................ De tjocka stigarna är DS och spräckta pseudokanter är avrättningsordern i ett kluster. Vi ger en förklaring för varje steg nedan. Överskriften av en aktivitetsnod i F L eller P F L anger dess prioritetsvärde. (0) Inledningsvis UEG = fn 1 ; n 2 ; n 3 ; n 4 ; n 5 ; n 6 ; n 7 g P T 0 = 13 F L = fn (1) n 1 väljs, tlevel(n 1 ) = 0, det kan inte minskas så CLUST (n 1 ) förblir en enhet kluster. Därefter UEG = fn 2; n 3; n 4; n 5; n 6; n 7 g P T 1 = 13 F L = fn g P F L = fg (2) n 2 väljs, n x = n 2, n y = NULL, och tlevel(n 2 ) = 4. Genom att nollställa den inkommande kanten (n 1 ; n 2 ) av n 2, t level(n 2 ) minskar till 1. Således accepteras denna nollställning och efter detta steg UEG = fn 3; n 4; n 5; n 6; n 7 g P T 2 = 10 F L = fn 1:5+8 3; n 0+9:5 4; n 0+7:5 5 g P F L = fn 9+1 7 g (3) n 3 väljs, n x = n 3 med P RIO(n 3 ) = 1:5 + 8 = 9.5 och n y = n 7 med pP RIO(n 7 ) = 10. Lägg märke till att genom nollställning (n 2 ; n 7) minskar tlevel(n 7 ) till 8,5. På så sätt inför vi DSRW-begränsningen. Eftersom nollställning (n 1 ; n 3 ) aects tlevel(n 7 ) accepteras inte denna nollställning på grund av DSRW. T-nivån(n 3 ) förblir densamma och CLUST (n 3 ) förblir en enhetskluster i EG. (4), (5) n 4 och n 5 väljs ut och deras kluster förblir återigen enhetskluster. Därefter väljs UEG = fn 6; n 7 g P T 5 = 10 F L = fn 5+4:5 6 g P F L = fn 9+1 7 g (6) n 6 och dess inkommande kanter (n 3; n 6) och (n 4; n 6) nollställs genom minimeringsförfarandet. Node n 4 beordras för utförande rst eftersom tlevel(n 4 ) = 0, vilket är mindre än tlevel(n 3 ) = 1:5. Då 16 är inte i CLUST (n 1 ) måste extraheras från deras motsvarande kluster och fästas vid CLUST (n 1 ). Dessa bifogade föregångare är beordrade att avrättas i en ökande ordning av sina t level värden. Vi avgör hur komplicerat detta förfarande är. T-nivån beställning av alla föregångare görs en gång till en kostnad av O(m log m). Den binära sökningen beräknar eekten av de beställda föregångarena till tlevel(n x ) till en kostnad av O(m) för O(log m) steg. Den totala kostnaden för ovanstående algoritm är O(m log m). Om linjär sökning användes istället skulle den totala kostnaden öka till O(m 2 ). Som vi såg tidigare när det inte finns någon DS går igenom någon fri uppgift och det finns en DS passerar genom en partiell fri nod n y, sedan nollning icke-DS inkommande kanter av fria noder kunde aekt minskningen av tlevel (n y ) i de framtida stegen. Vi inför följande begränsning på DSC för att undvika sådana sidoeekter: DSRW: Zeroing inkommande kanter av en fri nod bör inte aekt minskningen av ptlevel (n y ) om det är reducible genom att nollställa en inkommande DS kant av n y. Det finns två problem som vi måste ta itu med vid genomförandet av DSRW. Först måste vi upptäcka om ptlevel (n y ) är reducible och andra måste vi se till att DSRW är mätt. 1. Vad är det för fel på dig? För att upptäcka reducibiliteten av ptlevel (n y ) måste vi undersöka resultatet av nollställning av en inkommande DS kant av n y. Till nd en sådan inkommande DS kant vi bara undersöka resultatet av nollställning varje inkommande kant (n j ; n y ) där n j är en föregångare till n y och n j 2 EG. Som vi kommer att bevisa i avsnitt 4.5 ptlevel(n y ) = tlevel(n y ). Detta innebär att sådana partiella reducibility suces att garantera att om den parallella tiden var reducible genom att nollställa DS inkommande kanter av en partiell fri DS node n y, då tlevel (n y ) är reducible när n y blir fri. Därför kan DS komprimeras på den tiden. 2. Utgångspunkten är följande: Efter att ha upptäckt partiell reducibilitet i steg i för node n y, vi genomför begränsningen DSRW enligt följande: Antag att n p är en undersökt föregångare n y och nollning (n p ; n y ) skulle minska ptlevel( n y ), då inga andra noder tillåts flytta till CLUST (n p ) tills n y blir fri. Till exempel i Bild. 4 (2), n y = n 5, ptlevel(n 5 ) = 1 + 2 + c 2,5 = 7:5, pP RIO(n 5 ) = 9:5, P RIO(n 3 ) = 4:5 och P RIO(n 4 ) = 9. Vi har att pP RIO(n 5 ) > P RIO(n 4 ), vilket innebär att DS går igenom partiell fri nod n 5 av Theorem 4.1 i avsnitt 4.5. Och ptlevel(n 5 ) skulle kunna minskas om (n 2 ; n 5 ) nollställdes. Därefter kan inte CLUST (n 2 ) vidröras innan n 5 blir fri. Således kan n 3 och n 4 inte flyttas till CLUST (n 2 ) och de förblir i enheten kluster i EG. När nally n 5 blir fri, (n 2 ; n 5 ) är nollad och P T minskas från 9,5 till 9. 4.4 Ett löpande spår av DSC 15 1. EG = ;. UEG = V. Lägg till alla fria ingång noder till F L. Beräkna blevel för varje nod och ställ in tlevel = 0 för varje fri nod. 3. Vad är det som händer? WHILE UEG 6 = ; DO 4. n x = head(F L); / * den fria uppgiften med högsta prioritet P RIO. */ 5. n y = huvud(P F L); /* partiell fri uppgift med högsta prioritet pP RIO.*/ 6. Förhöjda värden (i mg/ kg/ kg/ kg/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml/ ml. Om (P RIO(n x) pP RIO(n)) THEN 7. Ring minimeringsförfarandet för att minska t level(n x ). 8. Vad är det som händer? Om ingen nollställning accepteras, finns n x kvar i ett enhetskluster. 9. Utövande av delegeringen av befogenhet ELSE Ring minimeringsförfarandet för att minska tlevel(n x ) under begränsning DSRW. Om ingen nollställning accepteras, finns n x kvar i ett enhetskluster. Detta anslag är avsett att täcka utgifter för tjänstemän och tillfälligt anställda som arbetar inom politikområdet Sysselsättning, socialpolitik och lika möjligheter för kvinnor och män i enlighet med bestämmelserna i Europaparlamentets och rådets förordning (EU, Euratom) nr 966/2012 av den 25 oktober 2012 om finansiella regler för unionens allmänna budget och om upphävande av rådets förordning (EG, Euratom) nr 1605/2002 (EUT L 298, 26.10.2012, s. 1). Uppdatera prioriteringarna för n x: s efterträdare och sätta n x i EG. 14. Vad är det för fel på dig? Figur 7 : DSC-algoritmen. accepterade nollställning. En annan optimal algoritm för att gå är att bestämma den optimala punkten k rst genom att använda en binär sökning mellan 1 och m sådan att ( P k01 j=1 j k ) och sedan noll alla kanter till vänster om k. Vi ändrar den optimala binära sökning gå algoritm för att minimera tlevel(n x ) när n x är fri. Förfarandet visas i bild. 8............................................................... Antag att P RED(n x ) = fn 1 ; n 2 ; 1 11; n m g. Observera att alla föregångare är i EG men nu CLUST (n 1 ); 1 1 1; CLUST (n m ) kanske inte är enhet kluster. Vi sorterar föregångarna till n x så att tlevel(n j) + j + c j;x tlevel(n j+1) + j+1 + c j+1;x. För att minska t level(n x ) måste vi noll kanten (n 1 ; n x ). Ett problem uppstår när algoritmen nollor en kant av en föregångare n p som har andra barn än n x. När uppgift n p flyttas från CLUST (n p ) till CLUST (n 1 ), kommer t-nivån för barn i n p aected. Följden blir att längden på de vägar som går genom dessa barn med största sannolikhet kommer att öka. Begränsningen P T i01 P T i får inte längre hålla och upprätthålla uppgiften prioriteringar blir komplicerat. För att undvika sådana fall, kommer vi att utesluta från minimering förfarande föregångare som har barn andra än n x om de är redan i CLUST (n 1 ). 1. Vad är det för fel på dig? Sortera föregångarna till n x så att tlevel(n j) + j + c j;x tlevel(n j+1) + j+1 + c j+1;x; j = 1 : m 0 1: 2. Låt h vara det maximala heltal från 2 till m sådan att för 2 t h node n t mättes följande begränsning: Om n t inte är i CLUST (n 1 ), sedan n t inte har några barn andra än n x. 3. Vad är det som händer? Hitta den optimala punkten k mellan 1 och h med hjälp av den binära sökalgoritmen. Noll (n 1 ; n x ) upp till (n k ; n x ) så att t level (n x ) är minimum. Den binära sökalgoritmen i Bild. 8 nds den bästa stopppunkten k och de föregångare av n x att 14 skulle också ha minskats med 5. Men på grund av den topologiska traversal regeln, en fri uppgift n 4 väljs i steg 3 eftersom P RIO(n 4 ) = 9 P RIO(n 3 ) = 4:5. Därefter slås n 4 ihop till CLUST (n 1 ) eftersom t level(n 4 ) kan minskas från 3 till 1 + 2 = 2:5. Denna process påverkar den framtida kompressionen av DS < n 1 ; n 2 ; n 5 >. När n 5 är fri i steg 5, tlevel(n 5 ) = 1 + 2 + c 2,5 = 7:5 och det är omöjligt att minska tlevel(n 5 ) ytterligare genom att flytta den till CLUST (n 2 ). Detta beror på att n 5 måste länkas efter n 4, vilket gör tlevel(n 5 ) = 1 + 2 + 4 = 8:5. De viktigaste förbättringarna av DSC-I är minimeringsförfarandet för tlevel(n f ), behålla en partiell frilista (PFL) och införa begränsningen DSRW. Vid varje kluster steg, vi upprätthåller två nod prioritetslistor, en partiell fri lista P F L och en fri lista F L båda sorteras i fallande ordning av sina uppgiftsprioriteringar. När två uppgifter har samma prioritet väljer vi den med de mest omedelbara efterträdare. Om det fortfarande finns en slips, bryter vi den slumpmässigt. Funktionshuvud(L) returnerar rst noden i den sorterade listan L, vilket är uppgiften med högsta prioritet. Om L = fg, head(L) = NULL och prioritetsvärdet är satt till 0. En nods tlevelvärde förökas till dess efterträdare först efter det att denna nod har undersökts. Således kan prioritetsvärdet av en partiell fri nod uppdateras med hjälp av endast tnivå från dess undersökta omedelbara föregångare. Eftersom endast en del av föregångaren beaktas, anger vi prioriteringen av en partiell fri uppgift: pP RIO(n y ) = ptlevel(n y ) + blevel(n y ); ptlevel(n y ) = max n j 2PRED(n ) T EG ftlevel(n j ) + j + c j;y g: I allmänhet, pP RIO(n y ) P RIO(n y ) och om en DS går genom en kant (n j ; n y ) där n j är en granskad föregångare till n y, då har vi pP RIO(n y ) = P RIO(n j ) = P RIO(n j ) = P RIO(n y ). Genom att upprätthålla pP RIO istället för P RIO komplexiteten minskas avsevärt. Eftersom vi kommer att visa senare underhåll pP RIO inte negativt påverkar prestanda DSC eftersom det fortfarande kan korrekt identifiera DS vid varje steg. DSC-algoritmen beskrivs i bild. 7. Vad är det som händer?  För att minska tlevel(n x ) i DSC behövs ett minimeringsförfarande som nollar flera inkommande kanter av fri aktivitet n x. En optimal algoritm för en anslutning DAG har beskrivits i [9] och en optimal lösning visas i bild. 6 c............................................................................................................ Den grundläggande proceduren är att rst sortera noderna så att j + j+1 + j+1 ; j = 1 : m 0 1, och sedan nollställer kanterna från vänster till höger så länge parallelltiden minskar efter varje nollställning, dvs.. linjär sökning av den optimala punkten. Detta motsvarar att uppfylla villkoret ( Samgåendet exemplet visar att nollställning endast en inkommande kant av n x inte är tillräckligt för att uppnå den optimala. I allmänhet, när en fri nod undersöks, kan nollställning flera inkommande kanter av denna fria nod i stället för nollning en kant resultera i en minskning av tnivå i en maximal grad. Som en följd av detta kan längden på DS eller SubDS som går igenom denna nod minskas ännu mer avsevärt. För att uppnå ett så girigt mål krävs ett lågt minimeringsförfarande som nollar flera inkommande kanter av den valda fria noden för att introduceras i DSC-algoritmen. använde också idén att nollställa flera inkommande kanter av en uppgift för att beräkna en lägre gräns för schemaläggning av en DAG, med hjälp av en O(m 2 ) algoritm, men inga genomförbara scheman som når gränsen produceras av hans algoritm. Eftersom vi är intresserade av lägre komplexitet algoritmer kommer vi att använda en ny optimal algoritm med en O(m log m) komplexitet. Vi beskriver ett annat problem med DSC-I. När en DS-nod n y är delvis fri, upphäver DSC-I nollställningen av dess inkommande kanter och undersöker de nuvarande icke-DS-fria noderna enligt topologisk ordning. Anta att t level(n ) skulle kunna minskas med om en sådan nollställning inte avbröts. Vi bör kunna få åtminstone samma minskning för t level (n y ) när DSC-I undersöker den fria noden n y i ett framtida steg. Då kommer längden på DS som går igenom n y också att minskas. Detta är dock inte fallet med DSC-I. Bilda. 4.2 visar resultatet av steg 2 av DSC-I efter n 2 slås samman till CLUST (n 1 ). Den nya DS avbildas med den tjocka pilen är < n 1 ; n 2 ; n 5 > och det går igenom partiell fri nod n 5. Om (n 2 ; n 5) nollställdes i steg 3, skulle tnivå(n 5) ha minskats med = 5. Därefter är längden på den nuvarande DS < n 1 ; n 2 ; n 5 > kvar i en enhet kluster och EG = fn x g. Därefter n 1 ; n 2 ; 1 11; n m blir fri och n 1 har högsta prioritet, P RIO(n 1 ) = x + 1 + 1, och t level(n 1 ) = x + 1. I steg 2 som visas i 5 c, n 1 väljs och slås samman till kluster av n x och t level(n 1 ) minskas i en maximal grad till x. Vid steg k + 1, är n k vald. Den ursprungliga vänster mest schemalagda kluster i 5 d är en \linjär" kedja n x ; n 1 ; 1 11; n k01. Om anslutning n k till slutet av denna kedja inte ökar tlevel(n k) = x + k, nollställning av kanten (n x ; n k ) accepteras och den nya tlevel(n k ) = x + P k01 j=1 j. Således villkoret för att acceptera eller inte acceptera en nollställning kan uttryckas som: Det är lätt att kontrollera att DSC-I alltid nollställer DS kanter vid varje steg för en gaffel DAG och parallelltiden minskar strikt monotont. Det visar sig att DSC-I algoritmen är optimal för detta fall och ett bevis kommer att ges i avsnitt 5. Låt oss överväga DSC-I algoritmen för att ansluta DAGs. Bilda. 6 visar en anslutning DAG, nal klustret och den optimala klustret. Återigen antar vi att j + j j+1 + j+1 ; j = 1 : m 0 1: Stegen i DSC-I beskrivs nedan. Bilda. 6 a) visar den ursprungliga klusterbildningen. Noder n 1 ; n 2 ; 1 1 1; n m är fria. En DS är < n 1 ; n x >. Steg 1 väljer n 1 som är i DS. Ingen inkommande kant finns för n 1 och ingen nollställning utförs. DS är fortfarande < n 1 ; n x > efter steg 1. Nu blir n x delvis fri. En nod är delvis fri om den är i UEG och åtminstone en av dess föregångare har undersökts, men inte alla dess föregångare har undersökts. Steg 2 väljer n 2 som inte är i DS. Ingen inkommande kant finns och n 2 finns kvar i en enhetskluster i EG. Steg m + 1 väljer n x som nu är i DS och sedan (n 1 ; n x ) är noll. Det slutliga resultatet av DSC-I visas i bild. 6 b) som kanske inte är optimal. Det optimala resultatet för en joint DAG visas i Bild. 6(c) är symmetrisk till den tidigare optimala lösningen för en gaffel. 11 kanter. När en fri nod slås ihop till ett \linjärt "kluster är den alltid fäst vid den sista noden av det \linjära" klustret. Således förblir tlevel(n x ) oförändrad efter n x har undersökts. Bevis: Från egendom 3.2, prioriteringen av en fri nod n f kan enkelt bestämmas genom att använda tlevel(n f ) = max n j 2PRED(n f ) ftlevel(n j ) + j + c j;f g: När tlevel(n j ) beräknas efter dess undersökning i något steg, där n j är föregångaren till n f, detta värde sprids till tlevel(n f ). Efteråt förblir tlevel(n j ) oförändrad och kommer inte att påverka värdet av tlevel(n f ) längre. Vi upprätthåller en prioriteringslista F L som innehåller alla fria uppgifter i UEG vid varje steg av DSC-I. Denna lista kan genomföras med hjälp av en balanserad sökträd datastruktur [7]. I början är F L tomt och det finns inga initiala overhead vid upprättandet av denna datastruktur. Omkostnaderna inträffar för att upprätthålla rätt ordning bland uppgifter när en uppgift infogas eller tas bort från denna lista. Denna operation kostar O(log jFLj) [7] där jFLj v. Eftersom varje uppgift i en DAG sätts in i F L en gång och raderas en gång under hela utförandet av DSC-I, är den totala komplexiteten för att upprätthålla F L högst 2v log v. Den huvudsakliga beräkningskostnaden för DSC-I algoritm spenderas i Medan loop (Line 4 i bild. Denna förordning träder i kraft den tjugonde dagen efter det att den har offentliggjorts i Europeiska unionens officiella tidning. Antalet steg (iterationer) är v. För linje 5, varje steg kostar O(log v) för nding huvudet av F L och v steg kostar O(v log v). För linje 6, varje steg kostar O(jP RED(n f )j) att undersöka de omedelbara föregångaren till uppgift n f. För v steg kostnaden är P n f 2V O(jP RED(n f )j) = O(e). För linje 7, varje steg kostar O(jSUCC(n f )j) att uppdatera de prioriterade värdena för de omedelbara efterträdare n f, och på liknande sätt kostnaden för v steg är O(e). När en efterträdare till n f hittas gratis på linje 7, läggs den till F L, och den totala kostnaden har uppskattats ovan vara O(v log v). Den totala kostnaden för DSC-I är alltså O(e + v log v). I detta underavsnitt studerar vi DSC-I:s prestanda för vissa DAG:er och föreslår modifikationer för att förbättra dess prestanda. Eftersom en DAG består av en uppsättning fog- och gaffelkomponenter, anser vi DSC-I:s styrkor och svagheter i schemaläggningsgaffeln och går med i DAG:s. Sedan diskuterar vi ett problem som uppstår när nollställning icke-DS kanter på grund av topologisk beställning av traversal. Bilda. 5 visar klustret steg DSC-I för en gaffel DAG. Utan förlust av allmängiltighet, anta att blad noderna i a är sorterade så att j + j j+1 + j+1 ; j = 1 : m 0 1: Stegen beskrivs nedan. Bilda. 5 b) visar den ursprungliga klusterbildningen där varje nod befinner sig i en enhetskluster. EG = fg, n x är den enda fria uppgiften i UEG och P RIO(n x ) = x + 1 + 1. Vid steg 1, n x är markerad och det har inga inkommande kanter. Det går igenom n f kan komprimeras och som ett resultat DS längd kan minskas. På bild. 4.2. n 2 väljs och (n 1 ; n 2 ) nollställs. Nollställningen accepteras eftersom tlevel(n 2 ) minskar från 6 till 1. Arbetsuppgiftsplacering i EG: (linje 6 i bild). 3 ) När en kant är nollad då en fri uppgift n f slås samman till kluster där en av dess föregångare bor. Vår schemaläggning heuristiska lägger till en pseudo kant från den sista uppgiften i detta kluster till n f om de är oberoende. På bild. 4.3, n 4 väljs och nollställning av (n 1 ; n 4 ) accepteras eftersom tlevel(n 4 ) minskar från 3 till 2.5. En pseudokant (n 2 ; n 4) läggs till i EG. DSC-I tillfredsställer följande egenskaper: Property 3.1 P T i01 P T i. Ekvation (1) innebär att en minskning av uppgifternas prioriterade värde skulle leda till en minskning av parallelltiden. Således innebär begränsningen att tlevel värden inte ökar denna egenskap. Ett formellt bevis ges i avsnitt 4.5. I DSC-I återanvänds tlevel- och blevelvärden efter varje steg så att komplexiteten i att bestämma DS-noder minskas. Följande egenskap förklarar hur topologisk traversal och klustret sammansmältning regel dened i DSC-I beskrivning gör komplexiteten minskning möjligt. Egenskap 3.2 För DSC-I algoritmen förblir tlevel(n x ) konstant om n x 2 EG och blevel(n x ) förblir konstant om n x 2 UEG. Bevis: Om n x 2 UEG, då topologisk traversal innebär att alla ättlingar till n x är i UEG. Eftersom n x och dess ättlingar befinner sig i separata enhetskluster förblir blevel(n x ) oförändrad innan den undersöks. Även för noder i EG, alla kluster i EG kan betraktas \linear" genom att räkna pseudo utförande 9 1. EG = ;. UEG = V. 2. Beräkna blevel för varje nod och ange tlevel = 0 för varje post nod. 3. Vad är det som händer? Varje uppgift markeras oprövad och antas utgöra en enhetskluster. 4. Vad är det som händer? Medan det finns en oprövad nod Do 5. Hitta en gratis nod n f med högsta prioritet från UEG. 6. Vad är det som händer? Sammanfoga n f med kluster av en av sina föregångare så att tlevel(n f ) minskar i en maximal grad. Om alla nollor ökar t nivå (n f ), n f förblir i en enhet kluster. 7. Vad är det som händer? Uppdatera de prioriterade värdena för n f s efterträdare. 8. Vad är det som händer? UEG = UEG 0 fn fg; EG = EG + fn fg. Prioriterad denition och DS-identifiering: (linje 5 i bild. 3 ) Baserat på ekvation (1) anger vi prioriteringen för varje uppgift vid varje steg P RIO(n f ) = tlevel(n f ) + blevel(n f ): Således kan vi identifiera en DS nod som den med högsta prioritet. På bild. 4.0), DS noderna är n 1, n 2 och n 5 och de har högsta prioritet värde 14.5. Den topologiska ordningen för uppgifts- och kantundersökning: (Linje 5 i bild. 3 ) Under utförandet av DSC-I grafen består av två delar, den undersökta delen EG och den ogranskade delen UEG. Inledningsvis är alla noder markerade oprövade, se bild. 4)............................................................................................... DSC- I väljer endast en oprövad fri aktivitet n f med högsta prioritet. Sedan undersöker den en inkommande kant av denna uppgift för nollning eller inte nollning. På bild. 4, uppgifter som valts i steg 1, 2, 3, 4 och 5 är n 1, n 2, n 4, n 3 respektive n 5. Observera att den valda aktiviteten n f är i en DS om det finns fria DS noder, annars är det i en SubDS. På bild. 4, Steg 1 väljer aktivitet n 1 som är i DS men steg 3 väljer aktivitet n 4 som inte är i DS. Ordningen för ett sådant urval är likvärdig med topologiskt överskridande av grafen. Anledningen till att följa en topologisk ordning av uppgift undersökning och nollning en DS kant incident till det är att vi kan lokalisera eekten av kant nollställning på de prioriterade värdena för resten av de oprövade uppgifterna. På detta sätt, även om nollställning ändrar prioriteringarna för många noder, DSC-I behöver bara beräkna förändringar för noder som är omedelbara efterträdare till den nu undersökta uppgiften n f, se linje 7 i bild. 3............................................................... För Fig. 4.1. Efter det att n 1 har granskats behöver prioriteringen n 5 inte uppdateras förrän en av dess föregångare har granskats i steg 2. Fler förklaringar ges i Property 3.2. Kriteriet för nollställning av kant: (linje 6 i bild. 3 ) Kriteriet för att acceptera en nollställning är att värdet av tlevel(n f ) av högsta prioritet fri nod inte ökar med en sådan nollställning. Om det gör det accepteras inte sådan nollställning och n f blir ett nytt kluster i EG. Observera att genom att reducera tlevel(n f ) alla stigar 8 efter nollning en DS kant av en väg, de andra kanterna i den sökvägen kanske inte är i DS av den nya grafen. AP2: En DS nollställning av maximal vikt kant: Med tanke på en DS kan bli en SubDS genom att nollställa endast en kant av denna DS, behöver vi inte noll flera kanter i ett steg. Vi skulle i stället kunna göra mindre minskningar i parallelltiden vid varje steg och utföra fler steg. Till exempel kunde vi välja en kant till noll vid varje steg, säger den största viktkanten i DS. På bild. 2.0), längden på nuvarande DS < n 1 ; n 2 ; n 7 > kunde minskas mer genom nollställning kant (n 1 ; n 2 ) i stället för (n 2 ; n 7 ). Nollning av den största viktade kanten leder dock inte nödvändigtvis till en bättre lösning. AP3: En DS-kant nollställning med låg komplexitet: Istället för att nollställa den högsta kantvikten kunde vi tillåta mer exibilitet och välja att nollställa en DS-kant som leder till en låg komplexitetsalgoritm. Bestämmande av en DS för en klustererad DAG kan ta minst O(v + e) tid om beräkningen inte görs stegvis. Upprepa denna beräkning för alla steg kommer att resultera i minst O(v 2 ) komplexitet. Det är därför nödvändigt att använda en inkrementell beräkning av DS från ett steg till ett annat för att undvika att hela DAG sprids i varje steg. Det korrekta DS-kantvalet för nollställning bör bidra till den stegvisa beräkningen av DS i nästa steg. Det är inte klart hur man genomför AP1 eller AP2 med låg komplexitet och det finns heller ingen garanti för att AP1 eller AP2 blir bättre än AP3. Vi kommer att använda AP3 för att utveckla vår algoritm. 3. Vad är det som händer? Eftersom ett av målen är G3, dvs. För att minska antalet onödiga kluster och öka eektiviteten måste vi också tillåta nollställning av icke-DS-kanter. Frågorna är när man ska göra SubDS nollställning. Ett tillvägagångssätt är att alltid noll DS kanter tills algoritmen stannar och sedan följa upp med non-DS nollställning. En annan metod som används i detta dokument är att interferera non-DS nollställning med DS nollställning. Interleaving SubDS och DS nollställning ger mer exibilitet som gör det möjligt att minska komplexiteten. 4. Vad är det som händer? Eftersom vi inte tillåter backtracking de enda nollning steg som vi bör tillåta är de som inte ökar den parallella tiden från ett steg till nästa: P T i01 P T i : Sarkar inför denna begränsning uttryckligen i sin kant nollställning process, genom att jämföra parallelltiden vid varje steg. Här kommer vi att använda en implicit begränsning för att undvika explicit beräkning av parallelltid för att minska komplexiteten. I nästa underavsnitt presenterar vi en första version av DSC algoritm och sedan identifiera dess svagheter så att vi kan förbättra dess prestanda. En algoritmisk beskrivning av DSC-I ges i bild. 3............................................................... En oprövad nod kallas fri om alla dess föregångare har undersökts. Bilda. 4 visar den ursprungliga statusen (steg 0) och steg i av DSC-I, motsvarande den Medan loop i 7 Vid steg 5, kant (n 2 ; n 7 ) undersöks och genom att nollställa det den parallella tiden ökar från 10 till 11. På så sätt avvisas denna nollställning. På samma sätt avvisas steg 6 nollställning (n 1 ; n 3 ). I steg 7 (n 5 ; n 6 ) är nollad, en pseudo kant från n 5 till n 3 läggs till eftersom efter steg 6 blevel(n 3 ) = 3 och blevel(n 5 ) = 5. Slutligen produceras två kluster med P T = 10. 3 En inledande konstruktion av DSC Algoritm 3.1 Designöverväganden för DSC-algoritmen Som vi såg i föregående avsnitt nollar Sarkars algoritm den högsta kommunikationskanten. Detta kant, dock, kanske inte är i en DS som bestämmer parallelltiden och som ett resultat parallelltiden kanske inte minskas alls, (se nollställning av kant (n 4 ; n 6 ) i steg 1 Bild. 2).................................................................. För att minska parallelltiden måste vi undersöka schemat för en klustergraf för att identifiera en DS och sedan försöka minska dess längd. Huvudidén bakom DSC algoritmen är att utföra en sekvens av kant nollställning steg med målet att minska en DS vid varje steg. Utmaningen är att genomföra denna idé med låg komplexitet så att den kan användas för stora uppgiftsgrafer. Således skulle vi vilja utveckla en algoritm med följande mål: G1: komplexiteten bör vara låg, låt oss säga, O(v + e) log v). G2: Parallelltiden bör minimeras. G3: Eektiviteten bör maximeras. Det finns flera svårigheter i genomförandet av algoritmer som uppfyller ovanstående mål: 1. Målen G1, G2 och G3 kunde koniktera med varandra. Till exempel maximeringen av eektivitetskonikterna med minimeringen i parallelltiden. När sådana konikter uppstår prioriteras G1 framför G2 och G3 och G2 över G3. Med andra ord är vi intresserade av algoritmer med låg komplexitet som uppnår minsta möjliga parallelltid och största möjliga eektivitet. 2. Utgångspunkten är följande: Låt oss anta att DS har fastställts. Sedan finns det ett beslut om att välja kanter som ska undersökas 2 och nollställas. Begrunda exemplet i bild. 2.0............................................................................................................ Inledningsvis är DS < n 1; n 2; n 7 >. För att minska längden på den DS, måste vi nolla minst en kant i DS. Därför måste vi bestämma vilka kanter som ska nollställas. Vi kan nollställa antingen en eller båda kanterna. Om kanten (n 1 ; n 2 ) är nollad, då den parallella tiden minskar från 13 till 10. Om (n 2 ; n 7) nollställs minskar parallelltiden till 11. Om båda kanterna nollställs minskar parallelltiden till 9,5. Därför finns det många möjliga sätt att kant nollställa och vi diskuterar tre strategier: AP1: Multipel DS kant nollställning med maximal P T minskning: Detta är en girig strategi som kommer att försöka få den maximala minskningen av parallelltiden vid varje kluster steg. Det är dock inte alltid sant att flera DS kant nollställning kan leda till maximal P T minskning eftersom 2 Backtracking inte används för att undvika hög komplexitet. 6 beräkning av parallelltiden vid varje steg och detta problem är också NP-fullständig. Sarkar använder följande strategi: Beställ oberoende uppgifter i ett kluster genom att använda den högsta blevel rst prioritet heuristic, där blevel är det värde som beräknas i föregående steg. Den nya parallella tiden beräknas sedan genom att passera den planerade DAG i O(v + e) tid. Eftersom det finns e steg är den övergripande komplexiteten O(e(e + v)). Bilda. 1 a............................................................... Steg i kant undersökt PT om nollställning P T i 0 13 1 (n 4; n 6) 13 ja 13 2 (n 1; n 2) 10 ja 10 3 (n 3; n 6) 10 ja 10 4 (n 6; n 7) 10 ja 10 5 (n 2; n 7) 11 nr 10 6 (n 1; n 3) 11 nr 10 7 (n 5; n 6) 10 ja 10 Tabell 1 : Klustersteg av Sarkars algoritm som motsvarar bild. 2............................................................... Bilda. 2 visar klusterstegen i Sarkars algoritm för DAG i bild. 1 a............................................................... Den sorterade kantlistan med avseende på kantvikter är f(n 4; n 6); (n 1; n 2); (n 3; n 6); (n 6; n 7); (n 2; n 7); (n 1; n 3); (n 5; n 6)g: Tabell 1 spår genomförandet av denna algoritm där P T står för parallelltid och P T i är den parallella tiden för att utföra den klustererade grafen vid slutförandet av steg i. Inledningsvis är varje uppgift i ett separat kluster som visas i Bild. 2.0 och den tjocka stigen anger DS vars längd är P T 0 = 13. I steg 1, kant (n 4 ; n 6 ) undersöks och P T förblir 13 om denna kant är noll. Således accepteras denna nollställning. I steg 2, 3 och 4 visas i bild. 2.2, (3) och (4), alla undersökta kanter är noll eftersom varje nollställning inte ökar P T. CLUST (n x ) står för kluster av nod n x. Om ett kluster bara innehåller en uppgift kallas det ett enhetskluster. Vi skiljer mellan två typer av kluster, den linjära och den icke-linjära. Ett kluster kallas ickelinjärt om det finns två oberoende uppgifter i samma kluster, annars kallas det linjärt. På bild. 1 c, det finns två kluster, klustret som innehåller n 1 och n 2 är linjär och den andra klustret är icke-linjär eftersom n 3 och n 4 är oberoende uppgifter i bild. 1 a............................................................... Ett schema kräver en beställning av uppgifter i icke-linjära kluster. De icke-linjära klusteren av en DAG kan därför betraktas som linjära kluster i den planerade DAG om ordern om utförande mellan oberoende uppgifter räknas som kanter. En linjär klustring bevarar parallellismen som finns i en DAG, medan icke-linjär klustring minskar parallellismen genom att sekventiella parallella uppgifter. En ytterligare diskussion om denna fråga finns i Gerasoulis och Yang [9]. Den kritiska vägen för en klustrad graf är den längsta vägen i den grafen inklusive både icke-noll kommunikationskant kostnad och uppgift vikter i den vägen. Den parallella tiden för att utföra en klustererad DAG bestäms av den kritiska vägen för den planerade DAG och inte av den kritiska vägen för den klustererade DAG. Vi kallar den kritiska vägen för en planerad DAG den dominerande sekvensen, DS för kort, för att skilja den från den kritiska vägen för den klustererade DAG. För Fig. 1 c, den kritiska vägen för den klustererade grafen är < n 1 ; n 2 ; n 7 > och DS är fortfarande den vägen. Om vikten av n 5 ändras från 2 till 6 förblir den kritiska vägen för den klustrade grafen densamma < n 1 ; n 2 ; n 7 >, men DS ändras till < n 5 ; n 3 ; n 4 ; n 6 ; n 7 >. En väg som inte är en DS kallas en SubDS. Låt tlevel(n x ) vara längden på den längsta sökvägen från en ingång (överst) nod till n x exklusive vikten av n x i en DAG. Symmetriskt, låt blevel(n x ) vara längden på den längsta vägen från n x till en utgång (botten) nod. Till exempel i Fig. 1 c), tnivå(n 1 ) = 0, bnivå(n 1 ) = 10, tnivå(n 3 ) = 2; bnivå(n 3 ) = 4. Följande formel kan användas för att bestämma parallelltiden från en schemalagd graf: ftlevel(n x ) + blevel(n x )g: (1) Vårt tillvägagångssätt för att lösa schemaläggningsproblem med obegränsade resurser är att betrakta schemaläggningsalgoritmerna som att utföra en sekvens av klustringssteg. Faktum är att de flesta av de befintliga algoritmerna kan karakteriseras med hjälp av ett sådant ramverk [10]. Det första steget förutsätter att varje nod kartläggs i ett enhetskluster. I andra steg försöker algoritmen förbättra den tidigare klusterbildningen genom att slå samman lämpliga kluster. En sammanslagning utförs genom att nollställa en kant kostnad som förbinder två kluster 1. Vi anser Sarkars algoritm [17], pp. 123-131, som ett exempel på en klusteralgoritm som nollställer kant. Denna algoritm rst sorterar de e kanterna på DAG i en fallande ordning av kantvikter och utför sedan e klustering steg genom att undersöka kanter från vänster till höger i den sorterade listan. Vid varje steg undersöker den ena kanten och nollar denna kant om parallelltiden inte ökar. Sarkars algoritm kräver 1 Två kluster kommer inte att slås samman om det inte finns någon kant som förbinder dem eftersom detta inte kan minska parallelltiden. En riktad acyklisk uppgift graf (DAG) dened av en tuple G = (V; E; C; T ) där V är uppsättningen av uppgift noder och v = jV j är antalet noder, E är uppsättningen av kommunikationskanter och e = jEj är antalet kanter, C är uppsättningen av edge kommunikationskostnader och T är uppsättningen av nod beräkningskostnader. Värdet c i;j 2 C är den kommunikationskostnad som uppstår längs kanten e i;j = (n i ; n j ) 2 E, vilket är noll om båda noderna kartläggs i samma processor. Värdet i 2 T är exekveringstiden för node n i 2 V. P RED(n x ) är den uppsättning omedelbara föregångare n x och SUCC (n x ) är den uppsättning omedelbara efterträdare n x. Ett exempel på DAG visas Bild. 1 a) 7 uppgifter n 1 ; n 2 ; 1 11; n 7. Deras avrättningstider är på rätt sida av kulorna och kantvikterna är skrivna på kanterna. Två uppgifter kallas oberoende om det inte finns några beroendevägar mellan dem. Modellen för utförande av uppgifter är sammanställningstidens makrodataow-modell. En uppgift tar emot all input innan utförande påbörjas parallellt, kör till slutförandet utan avbrott, och omedelbart skickar utdata till alla efterföljande uppgifter parallellt, se Wu och Gajski [19], Sarkar [17]. Duplicering av samma uppgift i separata processorer är inte tillåtet. Med tanke på ett DAG och ett obegränsat antal helt anslutna processorer består schemaläggningsproblemet av två delar: Uppgiften till processortilldelning, som kallas klustring i detta papper och uppgiften utförande beställning för varje processor. En DAG med en given kluster men utan uppgiften utförande beställning kallas en kluster graf. En kommunikationskantsvikt i en klustrerad graf blir noll om start- och slutnoder i denna kant är i samma kluster. Bilda. 1 c visar en klustring av DAG i a) med undantag för de streckade kanterna. Uppgifterna n 1 och n 2 utgör en kluster och resten av uppgifterna en annan. Bilda. 1 b) visar en Gantt diagram över en schemaläggning där processorn tilldelning för varje uppgift och start och slutförande tider dened. Ett likvärdigt sätt att representera ett schema visas i bild. 1 c, kallas en planerad DAG. En planerad DAG innehåller både klustring och utförande beställning information. De streckade pseudokanterna mellan n 3 och n 4 i bild. 1 c) representerar den exekutionstitel som föreskrivs i tidsplanen. Starttiderna för uppgiften anges inte uttryckligen i en planerad DAG, utan kan beräknas genom att köra denna DAG. 3 klustren vidare till antalet fysiska processorer och även införliva nätverket topologi i sammanslagningssteget. I detta dokument presenterar vi en eektiv algoritm för det första steget i Sarkars strategi. Algoritmer för det andra steget diskuteras på annat håll [23]. Syftet med schemaläggningen är att fördela uppgifter på processorer och sedan beställa deras utförande så att uppgiften beroende är mätt och längden på schemat, känd som den parallella tiden, minimeras. I närvaro av kommunikation har komplexiteten i ovanstående schemaläggningsproblem visat sig vara mycket svårare än det klassiska schemaläggningsproblemet där kommunikationen ignoreras. Det allmänna problemet är NP-komplett och även för enkla grafer som ne korn träd eller konkatetering av en gaffel och en förening tillsammans komplexiteten är fortfarande NP-komplett, Chretienne [3], Papadimitriou och Yannakakis [15] och Sarkar [17]. Endast för särskilda klasser av DAGs, såsom gå, gaffel, och grova korn träd, särskilda polynom algoritmer är kända, Chretienne [4], Anger, Hwang och Chow [2]. Det har funnits två metoder i litteraturen för att ta itu med det allmänna schemaläggningsproblemet. Den första metoden beaktar heuristik för godtyckliga DAGs och den andra studien optimala algoritmer för speciella klasser av DAGs. När dubbelarbete är tillåtet har Papadimitriou och Yannakakis [15] föreslagit en ungefärlig algoritm för en DAG med lika arbetsvikter och lika kantvikter, vilket garanterar en prestanda inom 50 % av det optimala. Denna algoritm har en komplexitet av O(v 3 (v log v + e)) där v är antalet uppgifter och e är antalet kanter. Kruatrachue och Lewis [14] har också gett en O(v 4)-algoritm för en allmän TAG baserad på dubbelarbete. En diculty med att tillåta uppgift dubblering är att dubblerade uppgifter kan kräva duplicerade data bland processorer och därmed utrymme komplexiteten kan öka när du utför parallella program på riktiga maskiner. Utan dubbelarbete har många heuristiska schemaläggningsalgoritmer för godtyckliga TAG föreslagits i litteraturen, t.ex. Kim och Browne [13], Sarkar [17], Wu och Gajski [19]. En detaljerad jämförelse av fyra heuristiska algoritmer ges i Gerasoulis och Yang [10]. En diculty med de flesta befintliga algoritmer för allmänna DAGs är deras höga komplexitet. Så vitt vi vet finns ingen schemaläggningsalgoritm som fungerar bra för godtyckliga grafer, NDs optimala scheman för speciella DAGs och har också en låg komplexitet. Vi presenterar en sådan algoritm i detta dokument med en komplexitet av O(v + e) log v), kallas Dominant Sequence Clustering (DSC) algoritm. Vi jämför DSC med ETF algoritm av Hwang, Chow, Anger och Lee [12] och diskutera likheter och dierences med den MD algoritm som föreslagits av Wu och Gajski [19]. Organisationen är som följer: Avsnitt 2 introducerar de grundläggande begreppen. Avsnitt 3 beskriver en inledande utformning av DSC-algoritmen och analyserar dess svagheter. I avsnitt 4 presenteras en förbättrad version av DSC som tar hand om de initiala svagheterna och analyserar hur DSC uppnår både låg komplexitet och god prestanda. Avsnitt 5 ger en prestanda som är bundet till en allmän TAG. Det visar att prestandan hos DSC ligger inom 50% av den optimala för grovkorniga DAGs, och det är optimal för skarv, gaffel, grova sädesträd och en klass av ne korn träd. I avsnitt 6 diskuteras det relaterade arbetet, presenteras experimentella resultat och jämförs DSC:s prestanda med Sarkars, ETF:s och MD:s algoritmer.
De mest populära klustermetoderna är Dominant Sequence Clustering (DSC) REF.
DSC: Scheduling Parallel Tasks on an Unbounded Number of Processors
{'venue': 'IEEE Transactions on Parallel and Distributed Systems', 'journal': None, 'mag_field_of_study': ['Computer Science']}