Rundt og rundt og. Trettende forelesning

Transkript

1 Nettverksalgoritmer. Anvendelser og generaliseringer. Sirkulasjonsproblemet/ lineær programmering. (Kap ) Rundt og rundt og Trettende forelesning 1 Merk: Ikke sikkert alt dette blir gjennomgått forelesningen er satt inn i stedet for en planlagt g jesteforelesning.

2 Generalisert flyt 2

3 Som vanlig flyt, men hver kant har en kostnad. Ønsker maks flyt (eller flyt=k) med minimal kostnad. Eksempel på bruk: Mincost matching. Med kostnad 3 Løsning: Finn *billigste* flytforøkende sti.

4 Ingen stor generalisering, siden vi alltid kan legge på en «superkilde» og et «supersluk». Kan være praktisk å tenke på det slik likevel (jfr. matcheproblemet). Flere kilder/sluk 4

5 Hver node har tilbud/ etterspørsel. Kilder har tilbud, sluk har etterspørsel (negativt tilbud). Kan simuleres med vanlig flyt, så lenge vi har minst én kilde og ett sluk. Tilbud/etterspørsel 5

6 Her har vi mulighet til å tvinge flyt gjennom kantene ved å gi en nedre grense for flyten. Da begynner det å faktisk finne en lovlig flyt i det hele tatt også å bli et problem. For å finne en lovlig (men ikke nødvendigvis maksimal) flyt: Knytt t til s, og finn så en lovlig sirkulasjon ( flyt der alle noder har supply/ demand = 0). Dette kan reduseres/ transformeres til et flytproblem *uten* nedre begrensninger, der alle noder har fått satt tilbud lik summen av nedre inn-beskrankninger minus summen av nedre ut-beskrankninger. (Kapasiteten blir øvre minus nedre beskrankning.) *Maksimal* flyt kan (når man har en lovlig flyt) finnes ved å bruke en fremgangsmåte svært lik Ford Fulkerson let etter lovlige forøkende stier helt til det ikke går lenger. Nedre beskrankninger 6

7 Dekker mange varianter men ikke flervareflyt (som vi ser på under emnet lineær programmering). Sirkulasjon 7

8 Ingen kilder/sluk (tilbud/etterspørsel = 0) Øvre og nedre beskrankninger Kostnad Finn billigste sirkulasjon Litt vanskelig problem å løse; algoritmer for dette er helt klart utenfor pensum. Kilder og sluk (tilbud/etterspørsel) kan simuleres 8

9 Min-cost matching Gutter 0/1/c Jenter Juksenode Juksenode n/n/0 9 Kan også løses direkte med min-cost-flow, selvfølgelig.

10 Hvis dere ikke klarer å redusere til noe annet, er det gode sjanser for at dere kan redusere til dette. (I hvert fall heltallsprogrammering Men det er en NP-hard variant.) For optimalisering med ikke-lineære målfunksjoner eller beskrankninger kreves tyngre skyts ofte heuristiske (som simulert størkning eller kunstig evolusjon, for eksempel). Lineær programmering 10

11 max 120x x 2 (1) x (2) x (3) x 1 + x (4) x 1 0 (5) x

12 Vertex x1-coord x2-coord Active constraints , , , , ,3 250 x x1 12

13 max 120x x x 3 (1) x (2) x (3) x 1 + x (4) x 1 0 (5) x 2 0 (6) x 3 0 (7) x 2 + 3x

14 x Vertex x1-coord x2-coord x3-coord Active constraints ,5, ,5, ,4, ,3, ,3, ,5, ,3, ,5, x x1

15 Løst m/lp Kjente problemer 15

16 Bruker mer eller mindre Bellman-Ford. Nøyer oss med «singlepair» shortest path her. Korteste vei 16

17 Feil i tidligere bok Korteste sti fra s til t Maksimér d[t] Krev at: d[v] d[u] + w(u, v) for alle (u, v) d[s] = 0 17

18 Her bruker vi flytkonser vering/ Kirchoffs lover, bl.a. Maksimal flyt 18

19 Maksimér summen av f(s, v) over v Krev at: Merk: Flyt er knyttet til nodepar, mens kapasitet er knyttet til kanter. Hvis det går en kant hver vei så kan dette bli relevant. (Se mer om skew symmetry i boka.) f(u, v) c(u, v) f(u, v) = f(v, u) summen av f(u, v) over v = 0 (u s, t) Kan gjerne redusere dette ved å droppe unødvendige constraints (der kapasiteten er 0, f.eks. dvs. også der det ikke er kanter). Det vil gjerne bli mer effektivt. 19

20 Billigst flyt 20

21 Minimér summen a(u, v)f(u, v) over (u, v) Samme krav som for flyt Krev også at: summen av f(s, v) over v = d For min-cost-max-flow, finn f.eks. max-flow d separat 21

22 Eneste kjente polynomiske løsning: Uttrykk som lineært program og løs med en polynomisk LPalgoritme. Flervare-flyt 22

23 Vi har k ulike varer K 1 Kk K i = (si, ti, di) s i: Kilde Er en slik flyt mulig? t i: Sluk d i: Ønsket flyt Kapasitetene gjelder for summen av f i(u, v) 23

24 F.eks. minimér 0. Krev at: summen av fi(u, v) c(u, v) over i for alle (u, v) f i(u, v) = fi(v, u) summen av f i(u, v) = 0 over i for alle u si, ti summen av f i(si, v) = di over v for alle i 24

25 Det finnes mange modeller for parallellitet. Her får dere en liten smak av én av dem som er ment å modellere trådbasert parallellitet/ multicoreprogrammering. Mye av dette blir antagelig neste gang :) Parallellitet 25

26 Pensum Én av disse: A. Kapittel 27 (Cormen, 3. utg.) B. Minicourse on Multithreaded Programming 26

27 Fib(n) 1 if n 1 2 return n 3 else x = Fib(n 1) 4 y = Fib(n 2) 5 return x + y 27

28 Dokumentasjonen på nett spawner begge kallene; i det nye kapitlet i Cormen et al. spawnes bare ett av dem. P-Fib(n) 1 if n 1 2 return n 3 else x = spawn Fib(n 1) 4 y = Fib(n 2) 5 sync 6 return x + y 28 Dette er logisk parallellitet ikke faktisk. Hvor ting faktisk kjøres i parallell kommer an på scheduler og antall prosessorer. (Tilsvarende fork/join i UNIX, men med tråder.)

29 Hver runding kalles en strand (i originaldokumentasjonen, thread, men det kan kanskje være litt forvirrende). De lyse boksene er spawnede, mens de mørke er kalt på vanlig vis. P-Fib(4) P-Fib(3) P-Fib(2) P-Fib(2) P-Fib(1) P-Fib(1) P-Fib(0) P-Fib(1) P-Fib(0) 29 Avhengighetsgrafen er (naturlig nok) en DAG. En viktig del av den er spawntreet. Her er også den kritiske stien uthevet.

30 Når man analyserer algoritmer er det gjerne denne man vil beskrive: Kjøretiden, som funksjon av problemstørrelsen. T (n) 30

31 Den eneste endringen her er egentlig at vi legger til antall prosessorer, P, som parameter. T P (n) 31

32 For enkelhets skyld dropper jeg n som eksplisitt parameter i T P 32

33 Work T 1 Den tiden det tar på én prosessor; evt., antall noder i DAG-en. 33

34 Span T Tiden det tar med uendelig mange prosessorer. Evt., den lengste stien fra start til slutt (critical path). 34

35 A B T 1 (A B) =T 1 (A)+T 1 (B) T (A B) =T (A)+T (B) 35

36 A B T 1 (A B) =T 1 (A)+T 1 (B) T (A B) = max(t (A),T (B)) 36

37 Fibonacci T 1 (n) = T (n) =T (n 1) + T (n 2) + Θ(1) = Θ(φ n ) T (n) = max(t (n 1),T (n 2)) + Θ(1) = T (n 1) + Θ(1) = Θ(n) For P-Fib har vi altså eksponentielt arbeid med lineært spenn. 37

38 Det er ikke så enkelt å finne eksakte formler for Tp derfor er det nyttig å kunne bruke noen nedre beskrankninger, og kunne holde oss til T1, Tinf og P, som er lettere å finne. Ulikheter 38

39 The Work Law T P T 1 P 39 Tiden det tar kan ikke være lavere enn gjennomsnittsarbeidet per prosessor. (Går du under snittet hos én må du gå over hos en annen )

40 The Span Law T P T 40

41 Speedup T 1 T P Hvis vi går fra 1 til P prosessorer, hvor mye fortere går det? 41

42 The Work Law gir oss T 1 P T P Hvis vi går fra 1 til P prosessorer kan det maksimalt gå P ganger så fort. 42

43 Lineær speedup T 1 T P Θ(P ) 43

44 Perfekt speedup P ganger så fort med P prosessorer. Så: I tillegg til at vi vil at kjøretiden skal vokse langsomt som funksjon av n så vil vi at speedup-en skal vokse fort (helst lineært) som funksjon av P. Dvs., vi vil at algoritmen skal utnytte ekstra prosessorer så bra som mulig (i hvert fall opp til et visst antall). T 1 = P T P Men siden vi har problemer med å finne Tp så må vi gå noen omveier 44

45 Parallellitetsgrad (parallelism) T 1 T Kan sees på (i hvert fall) tre måter: (1) Gjennomsnittlig arbeid per trinn i kritisk sti (2) maksimal speedup 45 (3) grense for mulig perfekt speedup (Mer om det om en liten stund.)

46 Fibonacci ( T 1 (n) φ n T (n) = Θ n ) Vokser dramatisk som funksjon av n. Med andre ord, selv med enormt mange prosessorer skal det ikke noen stor n til før man har nærmest perfekt M.a.o.: Algoritmen kan nyttiggjøre seg alle kjernene du kan kaste etter den. 46

47 Flere pros. enn parallellitetsgrad T 1 T 1 <P T P T Perfekt speedup er da ikke lenger mulig. 47

48 Mange pros. ifht. parallellitetsgrad P T 1 T T 1 T P P Så parallellitetsgraden er bra eller dårlig i forhold til antall prosessor. Forholdet mellom parallellitetsgraden og antall prosessorer er altså viktig. 48

49 Scheduling Scheduleren fordeler strands mellom prosessorer mens programmet kjører uten forhåndskunnskap (dvs. on-line ). For å gjøre analysen enkel, brukes her en sentralisert, grådig scheduler. Ikke optimal, men ikke så veldig langt ifra Grådig scheduling: Utfør så mange strands som mulig i hvert trinn. 49

50 Grådig sched. på ideell par. maskin: T P T 1 P + T 50

51 Korollar T P 2T P En tidsdobling er en del men for asymptotisk analyse spiller det jo ingen rolle. (Grunnen til at vi bruker grådig scheduling her er først og fremst at det er greit å analysere.) 51

52 Enda et korollar P T 1 T T P T 1 P 52

53 Ekvivalent konklusjon T 1 P T P Altså: Ved høy parallellitet ifht. antall prosessorer gir grådig scheduling nesten perfekt speedup. 53

54 D&C Bellman-Ford BFS/DFS Binære søketrær LP Binærsøk Bubblesort Bucket sort Counting sort Dijkstra DAGshortest-path Edmonds- Karp Par.? Floyd- Warshall Hashing Gr. Heapsort Huffmankoding Insertion sort NPC Flyt+ Kruskal Merge sort Prim Quicksort Radix sort Randomized Select Select Θ etc. Selection sort Sterke komponenter Topologisk sortering DP 54

55 D&C Bellman-Ford BFS/DFS Binære søketrær LP Binærsøk Bubblesort Bucket sort Counting sort Dijkstra DAGshortest-path Edmonds- Karp +Par.! Floyd- Warshall Hashing Gr. Heapsort Huffmankoding Insertion sort NPC Flyt+ Kruskal Merge sort Prim Quicksort Radix sort Randomized Select Select Θ etc. Selection sort Sterke komponenter Topologisk sortering DP 55