Daten, Daten, Daten. Und immer an den Zugriff denken.

Transkript

1 Daten, Daten, Daten. Und immer an den Zugriff denken. Zusammenfassung In dieser Ausarbeitung wird ein externer Algorithmus beschrieben, welcher die Breitensuche auf ungerichteten Graphen mit wenig Kanten mit einem sublinearem Aufwand für die Anzahl der IO-Operationen in Bezug auf die Anzahl der Knoten durchführt. Schriftliche Ausarbeitung von Michael Hußmann im Rahmen des Seminars Perlen der Theoretischen Informatik. Wintersemester 2002/ Universität Paderborn

2 Inhaltsverzeichnis 1 Einleitung Externe Algorithmen Breitensuche Das Parallel Disk Model (PDM) Merkmale des PDM-Modells Parameter des PDM-Modells Fundamentale IO-Operationen Breitensuche Interner Algorithmus für die Breitensuche Probleme des internen Algorithmus Externe Breitensuche nach Munagala und Ranade Idee und Algorithmus Abschätzung der IO-Operationen Externe Breitensuche nach Mehlhorn und Meyer Idee des Algorithmus Partitionierungsphase Zieldarstellung und Verfahren Randomisierte Partitionierung Aufbau der Datenstruktur BFS-Phase Vorgehensweise Abschätzung der IO-Operationen Zusammenfassung 13 1

3 1 Einleitung Der Zusatz Und immer an den Zugriff denken auf der Titelseite gibt bereits einen wichtigen Hinweis auf den Inhalt meiner Seminararbeit: Um die Laufzeit von Algorithmen abschätzen zu können, wurden in der theoretischen Informatik verschiedene Rechnermodelle und Effizienzmaße entwickelt. Ein wichtiges Beispiel für ein Rechnermodell ist z.b. das der RAM (Random Access Machine), welches abstrakt die Arbeitsweise aller heutigen Rechner mit von-neumann-architektur beschreibt. Auf das RAM -Modell soll hier jedoch nicht genauer eingegangen werden, ebenso wenig auf die verschiedenen Effizienzmaße, die bereits bekannt sein sollten. Stattdessen soll der Blick des Lesers auf die Art und Weise gerichtet werden, wie mittels des RAM -Modells Laufzeiten von Algorithmen abgeschätzt werden: Ein wesentliches Merkmal ist, daß alle Speicherzugriffe als gleich teuer angesehen werden. Diese Abschätzung mag tatsächlich in vielen Fällen richtig sein bzw. als grobe Abschätzung genügen. Sie trifft jedoch nicht mehr zu, wenn ein Programm im Laufe seiner Ausführung auf unterschiedlich schnelle Speicher zugreift. 1.1 Externe Algorithmen Unterschiedlich schnelle Speicher liegen aber bei fast allen existierenden Rechnern vor: Damit die entsprechenden Systeme nicht zu teuer in der Anschaffung sind, ist der Speicher hierarchisch angeordnet. Auf der höchsten Ebene finden sich die Register der CPU, auf die sehr schnell zugegriffen werden kann. Dieser Speicher ist daher auch der teuerste. Auf der zweiten Ebene der Hierarchie befindet sich häufig ein sogenannter Cache-Speicher als Bindeglied zwischen der CPU und dem Hauptspeicher auf der nächsten Stufe. Im Cache-Speicher werden die als nächstes benötigten oder häufig benutzten Daten gespeichert, um die Zugriffe der CPU auf den langsamen Hauptspeicher zu beschleunigen, welcher erheblich billiger als der schnelle Cache-Speicher ist. Daher dauern Zugriffe auf den Hauptspeicher bei Verwendung von Cache-Speicher unterschiedlich lang, weil sich ein angefordertes Datum entweder im schnellen Cache-Speicher oder im langsamen Hauptspeicher befinden kann. Abbildung 1: Vereinfachte Speicher-Hierarchie in modernen Rechner-Architekturen. Auf der untersten Ebene dieser Hierarchie befindet sich der Sekundärspeicher, zu dem z.b. Festplatten, CD-ROM-Laufwerke etc. gehören, die sehr große Datenmengen speichern können, aber auch sehr langsam im Vergleich zu den anderen vorgestellten Speichern sind. Es lassen sich daher in Bezug auf Hauptspeicher und Sekundärspeicher dieselben Unterschiede in den Zugriffszeiten 2

4 beobachten, die vorhin beschrieben wurden. Diese Speicherhierachie macht somit in vielen Fällen eine genaue Laufzeitabschätzung eines Algorithmus unmöglich. Trotzdem sind Modelle wie das der RAM nicht unbrauchbar: Ist der Hauptspeicher eines Rechners groß genug für die Daten, die ein Programm benötigt, fallen zumindest die langsamen Zugriffe auf den Sekundärspeicher weg, welche mit Abstand am zeitaufwendigsten gegenüber Zugriffen auf andere Speicher sind: Typischerweise dauert ein Zugriff auf den Hauptspeicher (DRAM) ns bzw. auf den Cache-Speicher (SRAM) ns, während der Zugriff auf eine Festplatte (IDE) ca. 10 ms benötigt. Die Laufzeitabschätzung eines Algorithmus mit Hilfe des RAM -Modells ist daher in den meisten Fällen als ausreichend anzusehen, sofern keine Zugriffe auf Sekundärspeicher auftreten. Bei Problemen mit sehr großen Datenmengen wie z.b. umfangreichen Matrizen oder Graphen reicht der Hauptspeicher eines Rechners jedoch nicht mehr aus, d.h. Zugriffe auf den Sekundärspeicher sind nicht mehr zu vermeiden. Daher müssen sogenannte externe Algorithmen entwickelt werden, die die Zugriffe auf den Sekundärspeicher minimieren. Weiter werden neue Modelle benötigt, um die Laufzeiten dieser externen Algorithmen unter Berücksichtigung der verschieden schnellen Speicher abschätzen zu können. 1.2 Breitensuche Ein gut studiertes Verfahren in der theoretischen Informatik ist die Breitensuche, welche einen Graphen ebenenweise durchläuft. Neben der Graphtraversierung hat die Breitensuche viele andere Anwendungen wie z.b. die Partitionierung eines Graphens etc. Falls ein Graph komplett im Hauptspeicher eines Rechners abgebildet werden kann, sind optimale Algorithmen bekannt, die die Breitensuche in Zeit O( V + E ) durchführen können. Benutzt nun aber ein Algorithmus die Breitensuche zur Lösung eines Problems, dessen Platzbedarf größer als der zur Verfügung stehende Hauptspeicher ist, kann die Breitensuche mit den bekannten Algorithmen nicht mehr effizient durchgeführt werden, weil viele langsame Zugriffe auf den Sekundärspeicher auftreten. In dieser Ausarbeitung wird ein externer Algorithmus mitsamt verwendeter Datenstruktur beschrieben, welcher die Breitensuche auf ungerichteten Graphen mit wenig Kanten so effizient löst, daß der Aufwand für die IO-Operationen sublinear in Bezug auf die Anzahl der Knoten ist. Diese Lösung wurde erst in diesem Jahr (2002) von Mehlhorn und Meyer [2] entwickelt und baut auf einer Idee von Munagala und Ranade [3] auf. In [1] findet sich eine weitere Beschreibung der Lösung, die weniger technisch aber dafür anschaulicher geworden ist. Der Rest dieser Ausarbeitung ist wie folgt gegliedert: In Kapitel 2 wird ein Modell vorgestellt, mit dem externe Algorithmen bewertet werden können. Kapitel 3 wiederholt das Verfahren der Breitensuche und begründet, warum die bekannten Algorithmen versagen, wenn die Daten im Sekundärspeicher abgelegt sind. Danach folgt in Kapitel 4 der Algorithmus von Munagala und Ranade, der in der vorzustellenden Lösung verwendet wird. Kapitel 5 beschäftigt sich ausführlich mit dem Verfahren von Mehlhorn und Meyer. In einer abschließenden Zusammenfassung werden kurz die wesentlichen Ergebnisse wiederholt. 2 Das Parallel Disk Model (PDM) Das Parallel Disk Model wird verwendet, um die Anzahl der IO-Operationen eines externen Algorithmus abschätzen zu können. Der Nutzen dieses Modells wurde bereits in der Einleitung motiviert. In diesem Kapitel werden in aller Kürze die wesentlichen Aspekte dieses Modells beschrieben. Für weitere Fragen sei auf den schönen Aufsatz von Vitter [4] verwiesen. 3

5 2.1 Merkmale des PDM-Modells Das PDM-Modell ist so konstruiert, daß drei wesentliche Kenngrößen zur Bewertung von externen Algorithmen ermittelt werden können: 1. Anzahl der IO-Operationen 2. Platzbedarf auf der Platte 3. CPU-Zeit Um die Bewertung der Algorithmen nicht unnötig kompliziert zu gestalten, konzentriert sich diese Ausarbeitung auf die Anzahl der IO-Operationen und geht auf den Platzbedarf auf der Platte nur am Rande ein. 2.2 Parameter des PDM-Modells Definition 2.1 (Problem-Parameter des PDM-Modells) Sei N die Größe des Problems, M die Größe des internen Speichers, B die Größe eines Blocks für einen Plattenzugriff, D die Anzahl der unabhängigen Platten und P die Anzahl der Prozessoren. Die Werte der Parameter N, M, B beziehen sich jeweils auf eine Anzahl an Elementen. Es gelte weiter: M < N und 1 D B M/2. D bezeichnet die Anzahl der Platten, die unabhängig voneinander angesprochen werden können. Dieser Parameter hat hohen Bezug zur Praxis, weil dort häufig sogenannte RAID-Systeme verwendet werden, die mehrere Platten ansteuern, um den Zugriff erstens zu beschleunigen und zweitens durch Redundanz die Ausfallsicherheit zu erhöhen. Die Bedingung M < N ist sinnvoll, weil sonst die Daten eines Problems vollständig in den Hauptspeicher passen würden. Folglich müßte ein interner Algorithmus betrachtet werden, so daß das PDM-Modell zur Auswertung ungeeignet wäre. Die Bedingung 1 D B M/2 hat folgende Hintergründe: Ein wichtiges Verfahren, von dem viele externe Algorithmen Gebrauch machen, ist Disk Striping. Die Idee ist, daß die Daten plattenübergreifend in mehreren Streifen (stripes) abgelegt sind. Dies ermöglicht den Zugriff auf B D aufeinanderfolgende Elemente mit einem Plattenzugriff. Eine Folge von N Elementen kann mit diesem Verfahren also mittels O(N/(D B)) IO-Operationen gelesen/geschrieben werden. Es ist anzumerken, daß bei Schreibvorgängen ein entsprechend großer Puffer zu verwenden ist. Abbildung 2: Visualisierung von Disk Striping für D = 5 und B = 2. 4

6 Sollen nun Daten in irgendeiner Form miteinander verknüpft oder verglichen werden, so sollte die Größe des internen Speichers mind. 2 B D sein, um die Daten von zwei Zugriffen aufnehmen zu können. Wichtig ist, daß beim Disk Striping bei einem Plattenzugriff nur auf solche Blöcke der einzelnen Platten zugegriffen werden darf, die in einem einzigen Streifen liegen. Im Prinzip verhalten sich also die D Platten wie eine einzige logische Platte mit entsprechend größerer Blockgröße. Die Anzahl der Prozessoren wird in dieser Ausarbeitung mit P = 1 angenommen, denn uns interessiert nur der Flaschenhals zwischen internem Speicher und den Platten. Außerdem ist der Fall P 1 wesentlich komplexer und würde von der eigentlichen Aufgabe, nämlich der Minimierung der IO-Operationen, nur ablenken. 2.3 Fundamentale IO-Operationen Bei der Auswertung von externen Algorithmen treten aufgrund der relativ großen Anzahl an zu berücksichtigenden Parametern des PDM-Modells komplizierte Terme für die Abschätzung der IO-Operationen auf. Zur Vereinfachung bezieht man sich daher oft auf die Abschätzungen von fundamentalen Operationen. Zwei dieser Operationen behandelt der folgende Satz; für weitere Details sei auf [4] verwiesen: Satz 2.1 (Fundamentale IO-Operationen) Sei F eine Datei im Sekundärspeicher, die aus x Elementen besteht. Dann gilt unter den oben genannten Bedingungen: F kann mittels scan(x) := O(x/(D B)) IO-Operationen sequentiell gelesen/geschrieben werden. F kann mittels sort(x) := O(x/(D B) log M/B (x/b)) IO-Operationen sortiert werden. Für einen Beweis des Satzes siehe [4]. Alle in diesem Kapitel eingeführten Bezeichnungen werde ich später ohne weitere Hinweise oder Erklärungen konsequent verwenden, um das Verständnis zu erleichtern. 3 Breitensuche Die Breitensuche wurde bereits in der Einleitung motiviert. In diesem Kapitel soll anhand eines internen Algorithmus verdeutlicht werden, warum auch i.a. interne Algorithmen für die Breitensuche versagen, wenn die Daten im Sekundärspeicher abgelegt sind. 3.1 Interner Algorithmus für die Breitensuche Es gibt viele verschiedene interne Algorithmen für die Breitensuche, die aber im Prinzip alle ähnlich vorgehen: Der erste zu besuchende Knoten eines Graphens wird einer FIFO-Queue hinzugefügt, die zu Beginn noch leer ist. Danach wird in einer Schleife jeweils ein Knoten aus der Queue entnommen und seine Nachfolger werden zur Queue hinzugefügt, sofern diese noch nicht besucht wurden. Die Schleife wird beendet, wenn die Queue leer ist. An dieser Stelle wird ein interner Algorithmus (entnommen aus [5]) vorgestellt, um dem Leser die Laufzeitabschätzung sowie die auftretenden Probleme bei der Verwendung von Sekundärspeicher besser erläutern zu können. 5

7 IM BF S(G, s) 1 for each vertex u ɛ V [G]-{s} do 2 color[u] := white 3 d[u] := 4 π[u] := nil 5 color[s] := gray 6 d[s] := 0 7 π[s] := nil 8 Q := {s} 9 while Q do 10 u := head[q] 11 for each v ɛ Adj[u] do 12 if color[v] = white then 13 color[v] := gray 14 d[v] := d[u] π[v] := u 16 enqueue(q,v) 17 dequeue(q) 18 color[u] := black Dieser Algorithmus benötigt Zeit O( V + E ), weil alle Adjazenzlisten durchlaufen werden (O( E )) und jeder Knoten einmal zur Queue hinzugefügt und wieder entfernt wird (O( V )). 3.2 Probleme des internen Algorithmus Ist der Hauptspeicher eines Rechners groß genug, um den Graphen vollständig aufzunehmen, so ist der vorgestellte Algorithmus für die Breitensuche optimal. Ganz anders sieht es aber aus, wenn der Graph im langsamen Sekundärspeicher liegt: Es müssen im schlimmsten Fall Θ( V + E ) IO-Operationen durchgeführt werden, die in der Praxis die Breitensuche und damit evtl. auch ein Programm, welches diese benutzt, stark verlangsamen. Dieses Problem betrifft zunächst einmal alle Verfahren zur Graph-Traversierung, also auch die bekannte Tiefensuche und das Single-Source-Shortest-Paths-Problem. Bei allen den Verfahren zugrunde liegenden Algorithmen lassen sich zwei wesentliche Probleme ausmachen: 1. Unstrukturierte Zugriffe auf die Adjazenzlisten 2. Unstrukturierte Abfragen, ob ein Knoten bereits besucht wurde Vor allem das erste Problem sieht wirklich dramatisch aus: Enthält eine Adjazenzliste k Kanten, so werden Θ(1 + k/b) IO-Operationen benötigt, um alle Kanten zu ermitteln. Falls k = Ω(B), lohnen sich die Zugriffe auf den Sekundärspeicher. Gilt dagegen k = O(1), so wird ein teurer Zugriff auf den externen Speicher für nur wenige Kanten durchgeführt. Ist der Graph dünn, d.h. die Adjazenzlisten i.a. eher kurz, so treten viele IO-Zugriffe auf, die bei weitem nicht die Blockgröße B für den Plattenzugriff ausnutzen. Insgesamt läßt sich festhalten: Es werden Θ( V ) viele IO- Operationen benötigt, um die Adjazenzlisten der einzelnen Knoten einzulesen. Das zweite Problem ist weniger schlimm und wird bereits von dem Algorithmus von Munagala und Ranade [3], der im nächsten Kapitel vorgestellt wird, gelöst: Es müssen Θ( E ) viele Abfragen durchgeführt werden, ob ein Knoten bereits besucht wurde. 6

8 4 Externe Breitensuche nach Munagala und Ranade 4.1 Idee und Algorithmus Im vorherigen Kapitel wurde darauf hingewiesen, daß der Algorithmus von Munagala und Ranade [3] bereits eine der zwei Ursachen für die hohe Anzahl an IO-Operationen verhindert, nämlich die unstrukturierten Abfragen, ob ein Knoten bereits besucht wurde. Die wesentliche Idee dieser Lösung ist es, nicht sofort den BFS-Baum zu berechnen, sondern zunächst nur die BFS-Level der einzelnen Knoten, d.h. die kürzesten Abstände vom Startknoten der Breitensuche zu den jeweiligen Knoten. Der BFS-Baum kann im Anschluß einfach aus den BFS-Leveln konstruiert werden. Dazu definiert man L(t) als Menge der Knoten auf Level t, d.h. mit BFS-Level t. Weiter sei A(t) die Multimenge der Nachbarknoten der Knoten aus L(t 1): A(t) := N(L(t 1)), wobei N(u) die Menge der Nachbarn eines Knotens u ist. Der Algorithmus berechnet nun sukzessiv eine Menge L(t) aus L(t 1), indem zunächst A(t) wie oben beschrieben berechnet wird. Anschließend werden die Duplikate aus A(t) entfernt. L(t) entsteht aus A(t) dadurch, daß alle Elemente entfernt werden, die bereits in L(t 1) und L(t 2) enthalten sind. Abbildung 3: Eine Phase im Algorithmus von Munagala und Ranade [3]. Der folgende Algorithmus (entnommen aus [3]) berechnet für jeden Knoten sein BFS-Level: Ist ein Knoten in der Menge L(t) enthalten, so ist sein BFS-Level t. MR BF S(G) 1 for each vertex u ɛ V [G] do C[u] := 0 2 L( 1) := L( 2) := 3 t := c := 0 4 while L(t 1) or unvisited vertices exist do 5 if L(t 1) = then 6 L(t) := next unvisited vertex 7 c := c else 9 A(t) := N(L(t 1)) 10 Remove duplicates from A(t) 11 L(t) := A(t) \ (L(t 1) L(t 2)) 12 for each vertex u ɛ L(t) do C[u] := c 13 t := t + 1 Aus den BFS-Leveln der Knoten lassen sich die BFS-Nummern berechnen, welche eine Ordnung auf den Knoten eines bestimmten Levels definieren. Mit Hilfe dieser BFS-Nummern kann anschlie- 7

9 ßend der BFS-Baum konstruiert werden. Dieser zusätzliche Aufwand kostet O(sort( V + E )) IO-Operationen. Für einen Beweis und weitere Details sei auf [6] verwiesen. Der hier vorgestellte Algorithmus funktioniert allerdings nur auf ungerichteten Graphen. Das Gleiche gilt für die Lösung von Mehlhorn und Meyer [2], welche im nächsten Kapitel behandelt wird, weil diese den Algorithmus von Munagala und Ranade verwendet. Ein Korrektheitsbeweis des Algorithmus für ungerichtete Graphen findet sich in [2]. Abbildung 4: Gerichteter Graph, bei dem die Idee von Munagala und Ranade [3] versagt. Abbildung 4 liefert ein Beispiel für einen gerichteten Graphen, auf dem die Breitensuche von Munagala und Ranade versagt. Der Grund ist, daß der Startknoten s in Runde 4 als einziger Knoten des Graphens in die Menge A(4) aufgenommen wird. Da s zu diesem Zeitpunkt nur in L(0) enthalten ist, wird es auch in die Menge L(4) aufgenommen. Damit ist s sowohl in L(0) als auch in L(4) enthalten. Im nächsten Durchlauf wird der Nachfolger von s in die Menge L(5) aufgenommen, obwohl sich dieser bereits in L(1) befindet usw. Der Algorithmus von Munagala und Ranada bricht also auf diesem Graphen niemals ab und findet stattdessen in jeder Runde scheinbar neue Ebenen mit unbesuchten Knoten. 4.2 Abschätzung der IO-Operationen Der folgende Satz liefert eine Abschätzung der IO-Operationen für die Breitensuche mit dem Algorithmus von Munagala und Ranade und der anschließenden Konstruktion des BFS-Baumes: Satz 4.1 (Breitensuche nach Munagala und Ranade) Die Breitensuche kann auf ungerichteten Graphen mit O( V + sort( V + E )) IO-Operationen durchgeführt werden. Beweis: Im Algorithmus von Munagala und Ranade treten die Zugriffe auf den Sekundärspeicher bei der Berechnung von L(t) aus L(t 1) auf. Man kann sich leicht klarmachen, daß gilt: t N(L(t)) = O( E ) und t (L(t) = O( V ). In Zeile 9 werden L(t 1) Zugriffe auf die Adjazenzlisten durchgeführt, um die Nachbarn der Knoten aus L(t 1) zu bestimmen. Der Gesamtaufwand für Zeile 9 im Algorithmus beträgt also O( V + scan( E )) IO-Operationen. Das Entfernen der Duplikate in Zeile 10 kann wie folgt realisiert werden: Zuerst werden die Multimengen sortiert. Anschließend werden die Mengen gemäß der Sortierung durchlaufen und die Duplikate entfernt. Pro Durchlauf werden somit O(sort( A(t) ) IO-Operationen durchgeführt. Der Gesamtaufwand im Algorithmus beträgt O(sort( E )) Zugriffe auf den Sekundärspeicher. 8

10 In Zeile 11 werden die Elemente aus A(t) entfernt, die bereits in L(t 1) und L(t 2) enthalten sind. Da alle diese Mengen sortiert sind, genügt ein Durchlauf durch A(t) mit gleichzeitigem Scannen von L(t 1) und L(t 2) für diese Aufgabe. Der Aufwand pro Durchlauf beträgt O(scan( A(t) + L(t 1) + L(t 2) )) IO-Operationen. Folglich benötigt der Algorithmus von Munagala und Ranade O( V + sort( E )) Zugriffe auf den externen Speicher. Jetzt muß noch der BFS-Baum konstruiert werden, was zusätzlich O(sort( V + E )) IO- Operationen kostet [6]. Folglich benötigt die Breitensuche mit diesem Verfahren O( V + sort( V + E )) Zugriffe auf den Sekundärspeicher. 5 Externe Breitensuche nach Mehlhorn und Meyer 5.1 Idee des Algorithmus Wie bereits mehrfach erwähnt, baut die hier vorzustellende Lösung auf der Idee von Munagala und Ranade auf, die im vorherigen Kapitel beschrieben wurde. Daher kann auch dieses Verfahren nur für die Breitensuche auf ungerichteten Graphen verwendet werden. Die grundlegende Idee ist die Unterteilung in zwei Phasen: In der ersten Phase (Partitionierungsphase) wird eine Datenstruktur aufgebaut, die den Zugriff auf die Adjazenzlisten beschleunigen soll. Wir erinnern uns: Der Standard-Algorithmus für die Breitensuche, welcher in Kapitel 3 wiederholt wurde, benötigt Θ( V + E ) IO-Operationen wg. der Zugriffe auf die Adjazenzlisten und den Abfragen, ob ein Knoten bereits besucht wurde. Der Algorithmus von Munagala und Ranade löst bereits das zweite Problem, indem einzelne Ebenen des Graphens betrachtet werden. Die Beschleunigung der Zugriffe auf die Adjazenzlisten durch eine Datenstruktur ist also ein weiterer wichtiger Schritt auf dem Weg zu einem Verfahren, welches die externe Breitensuche mit möglichst wenig IO-Operationen löst. Daher wird in der zweiten Phase (BFS-Phase) die Breitensuche mit dem Algorithmus von Munagala und Ranade unter Zuhilfenahme der erwähnten Datenstruktur durchgeführt. Dies soll soweit zur Motivation der Idee genügen. Weitere Details folgen in den nächsten Abschnitten. 5.2 Partitionierungsphase Zieldarstellung und Verfahren In der Partitionierungsphase wird eine Datenstruktur aufgebaut, welche in der nachfolgenden BFS- Phase die Zugriffe auf die Adjazenzlisten beschleunigen soll. Dazu wird der ungerichtete Graph in mehrere disjunkte zusammenhängende Teilgraphen S i, 0 i < K, zerlegt. Die Adjazenzlisten werden in der gleichen Weise partitioniert und in einer externen Datei F = F 0 F 1... F i... F K 1 gespeichert, wobei ein F i die Adjazenzlisten für einen Teilgraphen S i aufnimmt. Mehlhorn und Meyer geben zwei verschiedene Vorgehensweisen zur Berechnung der Teilgraphen S i an: Randomisierte Partitionierung: Eine Menge von Master-Knoten (master nodes) wird per Zufall unabhängig aus den Knoten des Graphens bestimmt. Anschließend werden von allen Master-Knoten aus Breitensuchen gestartet. Die besuchten Knoten der einzelnen Breitensuchen entsprechen den Knoten der Teilgraphen S i. 9

11 Deterministische Partitionierung: Der Spannbaum T s der Zusammenhangskomponente C s, welche den Startknoten s der Breitensuche enthält, wird konstruiert. Danach wird eine Euler- Tour entlang T s berechnet, welche eine Liste von Knoten liefert, wobei hier natürlich Knoten mehrmals auftauchen können. Diese Liste wird in mehrere Teile zerlegt und doppelte Knoten werden entfernt. Die Knoten in den einzelnen Listen entsprechen den Knoten der Teilgraphen S i. In dieser Ausarbeitung wird nur das randomisierte Verfahren behandelt, weil es anschaulicher und leichter zu verstehen ist. Auch Mehlhorn und Meyer geben diesem Verfahren in ihren Dokumenten [2] mehr Gewicht. Für weitere Informationen zum zweiten Verfahren sei auf die Literatur verwiesen Randomisierte Partitionierung Die Master-Knoten s i werden mit Wahrscheinlichkeit µ = min{1, scan( V + E )/ V } unabhängig gewählt. Aus technischen Gründen, die später noch deutlich werden, wird vorausgesetzt, daß der Master-Knoten von S 0 der Startknoten s der Breitensuche ist. Abbildung 5: Randomisierte Partitionierung auf einem Graphen (Ausschnitt): Knoten w wird sowohl von s i als auch von s j beansprucht. Nun werden von allen Master-Knoten s i aus Breitensuchen gestartet, welche im Prinzip parallel vorgehen: In jeder Runde nennt ein Master-Knoten alle noch unbesuchten Nachbarknoten seines aktuellen Teilgraphens S i. Wird ein Knoten nur von einem Master-Knoten s i genannt, so wird dieser in den Teilgraphen S i aufgenommen. Falls mehrere Master-Knoten einen Knoten für sich beanspruchen, entscheidet der Zufall, welcher ihn tatsächlich erhält. Satz 5.1 (Randomisierte Partitionierung) Die randomisierte Partitionierung kann mit O(scan( V + E )/µ+sort( V + E )) IO-Operationen durchgeführt werden. Beweis: Es ist leicht einzusehen, daß die erwartete Anzahl der Master-Knoten K := O(µ V ) beträgt. Die erwartete Pfadlänge zwischen zwei Master-Knoten beträgt aufgrund der unabhängigen Wahl höchstens 1/µ. Daher kann die erwartete Pfadlänge zwischen zwei Knoten eines Teilgraphens S i höchstens 2/µ betragen. Man betrachte nun die Vorgehensweise während einer Runde: Sei R i die Menge der tatsächlich erhaltenen Knoten für einen Master-Knoten s i in der vorherigen Runde. Das Ermitteln der unbesuchten Nachbarknoten für die Teilgraphen S i kann durch Sortieren der Mengen R i und Betrachten der Adjazenzlisten dieser Knoten durchgeführt werden. Damit läßt sich folgern, daß die bei der Partitionierung betrachtete Datenmenge (in Elementen) durch X := O( vɛv 1/µ (1 + degree(v))) = O(( V + E )/µ) beschränkt werden kann. 10

12 Weiter kann die Anzahl der Knoten in den Mengen R i und den Nachbarknoten, die während der gesamten Partitionierungsphase jeweils sortiert und durchlaufen werden müssen, durch Y := O( V + E ) beschränkt werden. Folglich benötigt die Partitionierung O(scan(X)+sort(Y )) = O(scan( V + E )/µ+sort( V + E )) IO-Operationen Aufbau der Datenstruktur Nach der Partitionierung liegt der ursprüngliche Graph als eine Menge von disjunkten und zusammenhängenden Teilgraphen S i vor. Nun muß noch die externe Datei F = F 0 F 1... F i... F K 1 erzeugt werden, wobei ein F i die Adjazenzlisten für einen Teilgraphen S i enthalten soll. Um die vorliegenden Teilgraphen in dem gewünschten Format zu speichern, muß eine konstante Anzahl von Scan- und Sort-Operationen aufgewendet werden, wie sich leicht einsehen läßt. Einträge in die F i sind von der Form (v, w, S(w), f S(w) ) und definieren eine Kante {v, w}, wobei w ein Knoten im Teilgraphen S(w) ist, dessen Datei F S(w) bei Position f S(w) in F beginnt. Die Einträge der einzelnen F i werden lexikographisch sortiert. Man kann sich leicht klarmachen, daß die externe Datei F insgesamt O(( V + E )/B) Blöcke auf der Platte bzw. den Platten belegt. 5.3 BFS-Phase Vorgehensweise In dieser Phase wird die eigentliche Breitensuche mit dem Algorithmus von Munagala und Ranade durchgeführt, wobei mit der erwähnten Datenstruktur die Zugriffe auf die Adjazenzlisten beschleunigt werden. Dazu wird eine sortierte externe Datei H (hot adjacency lists) verwendet, welche die aktuell benötigten Adjazenzlisten enthalten soll. Zu Beginn der Breitensuche wird H mit F 0 initialisiert, welches alle Adjazenzlisten für den Teilgraphen S 0 enthält, dessen Master-Knoten der Startknoten s der Breitensuche ist. Ein wesentliches Merkmal des Algorithmus von Munagala und Ranade ist das Berechnen von Mengen L(t) aus Mengen L(t 1) und L(t 2), um die BFS-Level der einzelnen Knoten zu erhalten. Dies kann mit Hilfe der externen Dateien H und F nun beschleunigt werden, weil auf die Adjazenzlisten der Knoten einer Ebene schneller zugegriffen werden kann: Anstatt Zugriffe auf einzelne Adjazenzlisten durchzuführen, kann ein Teil der benötigten Adjazenzlisten aus der Datei H mit sequentiellen Zugriffen gelesen werden. Genauer: Soll A(t) := N(L(t 1)) berechnet werden, werden die Adjazenzlisten aller Knoten V 1 L(t 1), die sich zur Zeit in H befinden, eingelesen. Es kann natürlich passieren, daß nicht alle Adjazenzlisten, die zur Berechnung von A(t) erforderlich sind, auf diese Weise ermittelt werden können, weil die restlichen Adjazenzlisten der Knoten V 2 := L(t 1) \ V 1 noch in den Dateien F i gespeichert sind. Daher werden nun in einem zweiten Schritt die entsprechenden Dateien F i ermittelt und eingelesen. Zur Beschleunigung weiterer Zugriffe werden die eingelesenen Adjazenzlisten sortiert und mit H gemischt. Insbesondere liegen jetzt aber alle Adjazenzlisten vor, die zur Berechnung von A(t) notwendig sind, so daß auch einer Berechnung der Menge L(t) analog zu Munagala und Ranade nichts mehr im Wege steht. Die berechneten Mengen L( ) werden sequentiell auf den Platten gespeichert und belegen folglich O( V /(D B)) Blöcke. Dies soll soweit zur Schilderung der Vorgehensweise genügen. 11

13 Abbildung 6: Ein Snapshot des Algorithmus von Mehlhorn und Meyer [2] vor der Breitensuche auf einem Graphen (Ausschnitt) Abschätzung der IO-Operationen Der folgende Satz liefert eine Abschätzung der IO-Operationen für die Breitensuche mit dem Verfahren von Mehlhorn und Meyer: Satz 5.2 (Breitensuche nach Mehlhorn und Meyer) Die Breitensuche kann auf ungerichteten Graphen mit O( V scan( V + E ) + sort( V + E )) IO-Operationen durchgeführt werden. Beweis: Zur Berechnung einer Menge L(t) müssen die externe Datei H sowie die Mengen L(t 1) und L(t 2) konstant viele Male eingelesen werden. Dieses kann zusätzlich beschleunigt werden, indem die ersten D B Blöcke dieser Mengen im internen Speicher untergebracht werden. Der eigentliche Aufwand verbirgt sich in der Aktualisierung der Datei H in jedem Schritt des Algorithmus: Es ist leicht einzusehen, daß eine Datei F i höchstens einmal zu H hinzugefügt wird. Weiter ist bekannt, daß der kürzeste Weg zwischen zwei Knoten eines Teilgraphens S i höchstens 2/µ beträgt. Damit läßt sich folgern, daß eine Adjazenzliste höchstens O(1/µ) Mal verwendet wird, nachdem diese zu H hinzugefügt wurde. Der Aufwand für die Aktualisierung von H läßt sich folgendermaßen unterteilen: 1. Einlesen von H während des Mischens 2. Einlesen der Adjazenzlisten aus den F i Aufgrund der Erklärungen läßt sich leicht folgern, daß die erste Aufgabe mit O(scan( V + E )/µ) IO-Operationen erledigt werden kann, denn eine Adjazenzliste wird höchstens O(1/µ) Mal verwendet, nachdem sie zu H hinzugefügt wurde. Bei der zweiten Aufgabe müssen die F i eingelesen und sortiert werden. Dies läßt sich mit O(µ V + sort( V + E ) + 1/µ scan( V + E )) IO-Operationen erreichen. Wählt man nun µ = min{1, scan( V + E )/ V } und nimmt die Abschätzung des Aufwands für die Randomisierte Partitionierung hinzu, so erhält man die Behauptung. 12

14 Ein analoges Resultat für die Abschätzung der IO-Operationen läßt sich auch für die deterministische Variante zeigen. Für weitere Informationen sei auf [2] verwiesen. In [2] erwähnen Mehlhorn und Meyer, daß bei dünnen Graphen mit E = O( V ) und realistischen Parametern im PDM-Modell der O( V scan( V + E ))-Term dominiert. In diesem Fall übertrifft ihre Lösung den Algorithmus von Munagala und Ranade [3] um Faktor Ω( D B). Bei dichten Graphen allerdings benötigen beide Verfahren O(sort( V + E )) IO-Operationen. 6 Zusammenfassung In dieser Ausarbeitung wurde gezeigt, daß die externe Breitensuche auf dünnen, ungerichteten Graphen mit sublinearem Aufwand für die IO-Operationen in Bezug auf die Anzahl der Knoten durchgeführt werden kann. Dazu wurde zuerst der Begriff des externen Algorithmus eingeführt und das PDM-Modell vorgestellt, mit dem der IO-Aufwand externer Algorithmen abgeschätzt werden kann. Als nächstes wurde ein interner Algorithmus für die Breitensuche wiederholt, der Laufzeit O( V + E ) benötigt, wenn sich der Graph im schnellen Hauptspeicher befindet. Liegt der Graph aufgrund seiner Größe jedoch im langsamen Sekundärspeicher, werden im schlimmsten Fall Θ( V + E ) IO-Operationen für die Breitensuche benötigt. Als Ursachen für dieses Verhalten wurden die Zugriffe auf die Adjazenzlisten sowie die Abfragen, ob ein Knoten bereits besucht wurde, identifiziert. Der daraufhin vorgestellte Algorithmus von Munagala und Ranade [3] berechnet zunächst die BFS-Level der einzelnen Knoten eines Graphens und konstruiert daraus den BFS-Baum. Durch diesen Ansatz werden die unstrukturierten Zugriffe, ob ein Knoten bereits besucht wurde, vermieden. Die Breitensuche benötigt mit diesem Algorithmus O( V + sort( V + E )) Zugriffe auf den Sekundärspeicher. Leider funktioniert dieser Ansatz nur auf ungerichteten Graphen. Nach diesen Vorbereitungen wurde die Lösung von Mehlhorn und Meyer [2] präsentiert, welche den Algorithmus von Munagala und Ranade verwendet. Die grundlegende Idee dieser Lösung ist die Partionierung des Graphens vor der eigentlichen Breitensuche und die Verwendung einer Datenstruktur für den Zugriff auf die Adjazenzlisten. Durch die Datenstruktur wird dieser Zugriff beschleunigt und damit die wesentliche Ursache für die hohe Anzahl an IO-Operationen interner Algorithmen für die Breitensuche vermieden bzw. abgeschwächt. Die Breitensuche kann mit diesem Verfahren mit O( V scan( V + E ) + sort( V + E )) IO-Operationen durchgeführt werden. Damit liegt nun ein Verfahren vor, mit dem die Breitensuche auf ungerichteten Graphen auch effizient durchgeführt werden kann, falls ein Graph im Sekundärspeicher wie z.b. auf einer Festplatte gespeichert ist. Dieses Resultat ist angesichts des großen Einsatzbereiches der Breitensuche natürlich sehr bedeutend, auch wenn die Lösung zunächst von theoretischer Natur ist. Aber Mehlhorn und Meyer behaupten in der entsprechenden Literatur, daß ihre Lösung auch praktisch einsetzbar ist. Dies kann sicherlich vom Leser bestätigt werden, wenn man sich an dieser Stelle die Vorgehensweise des Verfahrens und insbesondere die Benutzung der neuen Datenstruktur noch einmal anschaut. Eine wirkliche Antwort auf die Frage nach der Bedeutung dieses Verfahrens für die Praxis wird aber erst die nahe Zukunft bringen. 13

15 Literatur [1] I. Katriel, U. Meyer. Elementary Graph Algorithms in External Memory. In Algorithms for Memory Hierarchies, noch nicht veröffentlicht. [2] K. Mehlhorn, U. Meyer. External-Memory Breadth-First Search with Sublinear I/O. In Proc. 10th Ann. European Symposium on Algorithms (ESA), LNCS, pp Springer, [3] K.V. Munagala, A. Ranade. I/O-Complexity of Graph Algorithms. In Proc. 10th Ann. Symposium on Discrete Algorithms, pp ACM-SIAM, [4] J. S. Vitter. External memory Algorithms and Data Structures: Dealing with Massive Data. In ACM Computing Surveys, Vol. 33, No. 2, June 2001, pp [5] T. H. Cormen, C. E. Leiserson, R. L. Rivest. Introduction to Algorithms. The MIT Press, Twenty-third printing, [6] A. Buchsbaum, M. Goldwasser, S. Venkatasubramanian, J. Westbrook. On external memory graph traversal. In Proc. 11th Ann. Symposium on discrete Algorithms, pp ACM- SIAM,