Spezialvorlesung Online-Algorithmen

Spezialvorlesung
Online-Algorithmen
Matthias Westermann
Berthold Vöcking
Sommersemester 2005
Christian Sohler
Inhaltsverzeichnis
1
Einleitung
1.1 Grundbegriffe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2 Amortisierte Analyse . . . . . . . . . . . . . . . . . . . . . . . . . .
1.3 Grundlagen der Wahrscheinlichkeitsrechnung . . . . . . . . . . . . .
3
4
5
7
2
List-Accessing
2.1 Der Algorithmus Move-To-Front . . . . . . . . . . . . . . . . . . . .
2.2 Deterministische untere Schranke . . . . . . . . . . . . . . . . . . .
10
11
12
3
Selbstanpassende Suchbäume
3.1 Operationen auf Splay-Bäume . . . . . . . . . . . . . . . . . . . . .
3.2 Analyse der SPLAY-Operation . . . . . . . . . . . . . . . . . . . . .
3.3 Statische Optimalität von Splay-Bäumen . . . . . . . . . . . . . . . .
14
15
16
20
4
Paging
4.1 Ein optimaler Offline-Algorithmus . . . . . .
4.2 Deterministische Algorithmen . . . . . . . .
4.2.1 Nicht-kompetitive Algorithmen . . .
4.2.2 Marking-Algorithmen . . . . . . . .
4.2.3 Deterministische untere Schranke . .
4.2.4 Unterschiedliche Speichergrößen . .
4.3 Randomisierte Algorithmen . . . . . . . . . .
4.3.1 Randomisierter Marking-Algorithmus
4.3.2 Randomisierte untere Schranke . . .
.
.
.
.
.
.
.
.
.
22
22
23
24
24
25
26
27
27
28
5
Datenmanagement in Netzwerken
5.1 Definition des File-Allocation-Problems (FAP) . . . .
5.2 FAP auf Bäumen . . . . . . . . . . . . . . . . . . . .
5.3 Deterministische untere Schranke für FAP . . . . . . .
5.4 FAP auf allgemeinen Graphen . . . . . . . . . . . . .
5.4.1 Deterministische Approximation von Metriken
5.4.2 Probabilistische Approximation von Metriken .
5.4.3 Randomisierter Online-Algorithmus . . . . . .
.
.
.
.
.
.
.
30
31
31
34
35
35
37
39
1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
6
Lastbalancierung
6.1 Identische Maschinen . . . . . . . . . . . . . . . . . . . . . . . . . .
6.2 Eingeschränkte Maschinen . . . . . . . . . . . . . . . . . . . . . . .
6.3 Verwandte Maschinen . . . . . . . . . . . . . . . . . . . . . . . . . .
2
41
41
42
44
Kapitel 1
Einleitung
Die klassische Entwicklung und Analyse von Algorithmen geht davon aus, dass die
zur Lösung eines Problems benötigten Daten zu Beginn der Berechnungen vollständig
vorliegen. In vielen Anwendungen ist diese Annahme jedoch unrealistisch. Algorithmische Probleme, die in der Praxis auftreten, sind oftmals online, d.h. relevante Daten
treffen erst nach und nach im Laufe der Zeit ein. Ein Online-Algorithmus muss Ausgaben berechnen, ohne zukünftige Eingaben zu kennen. Das folgende Ski-Rental Problem wirkt etwas künstlich, jedoch zeigt es, dass wir häufig Entscheidungen treffen
müssen, deren Qualität durch das Auftreten oder Ausbleiben zukünftiger Ereignisse
beeinflusst wird.
Angenommen Du willst zum ersten Mal in Deinem Leben Ski fahren gehen. Lohnt
es sich für Dich, eine komplette Ski Ausrüstung zu kaufen, oder solltest Du sie Dir
zunächst einmal ausleihen? Eine komplette Ski Ausrüstung kostet eine Menge Geld,
aber wenn Du häufig fährst, dann ist sie die günstigste Lösung. Wenn sich aber nun
herausstellt, dass Dir Ski fahren keinen Spass macht, Du Dich verletzt oder Du aus
anderen Gründen nicht mehr Ski fahren möchtest oder kannst? Dann wäre es sicherlich
besser, die Ski nicht gekauft zu haben.
Leider weiß man beim Ski fahren nicht vorher, ob es einem gefällt oder nicht.
Deshalb muss man die Entscheidung, Ski zu kaufen, unabhängig vom Wissen über die
Zukunft treffen. Wir wollen nun das Ski-Rental Problem formalisieren: Nehmen wir
einmal an, dass eine Ski Ausrüstung 800 Euro kostet und das Leihen der Ski kostet 50
Euro/Tag. Außerdem nehmen wir zur Vereinfachung an, dass Ski ewig halten.
Wir wollen nun versuchen eine gute Strategie zu finden. Dazu m üssen wir uns erst
einmal überlegen, was eine gute Strategie auszeichnet. Eine Strategie ist dann gut,
wenn sie sicherstellt, dass wir – auch ohne die Zukunft zu kennen – nie viel mehr ausgeben, als nötig ist. Das bedeutet, dass wir sicher nicht sofort Ski kaufen, denn wenn
wir nur einmal Ski fahren gehen, hätten wir 800 Euro ausgegeben, aber im schlechtesten Fall hätten wir nur 50 Euro benötigt. Das heißt, in diesem Fall hätten wir das
16-fache des benötigten ausgegeben. Andererseits macht es auch keinen Sinn immer
wieder Ski auszuleihen, denn dann werden wir beliebig viel zahlen, wenn uns das Ski
fahren gefällt.
3
Daher werden wir folgende Strategie verfolgen: Wir werden Ski ausleihen bis wir
insgesamt 750 Euro Leihgebühr bezahlt haben oder wir aus irgendeinem Grunde nicht
mehr Ski fahren wollen. Danach werden wir uns eine Ausrüstung zulegen. Wir werden nun zeigen, dass man mit dieser Strategie nie mehr als das (2 − 1/r)-fache des
Bestmöglichen bezahlt, wobei r = 800/50 = 16 das Verhältnis zwischen den Kosten
für den Kauf und das Leihen von Ski ist. Angenommen wir w ürden die Zukunft kennen
und wüssten genau, dass wir k mal Ski fahren. Wenn k < r ist, dann ist die optimale
Strategie, Ski zu leihen. Ansonsten ist die optimale Strategie, Ski sofort zu kaufen.
Für k < r ist unsere Strategie optimal. Für k ≥ r werden wir mit unserer Strategie
(2r − 1) · x = 1550 Euro ausgeben, wobei x = 50 die Kosten für das Leihen der Ski pro
Tag bezeichnet. Im besten Fall hätten wir nur r · x = 800 Euro ausgegeben. Also hätten
wir das (2 − 1/r)-fache des Bestmöglichen bezahlt.
Auch in der Informatik gibt es Probleme, bei denen wir Dinge entscheiden m üssen,
bevor die eigentlich relevanten Ereignisse passieren. Zum Beispiel will man in einem
Cache möglichst gerade die Daten behalten, die in (naher) Zukunft angefragt werden.
Aber man weiß natürlich nicht, welche Daten das sind. Ein anderes Beispiel ist die Frage, wie (d.h. über welche Wege) man in einem Netzwerk die Datenpakete verschickt,
um eine gleichmäßige Auslastung des Netzwerkes zu gewährleisten. Auch hier weiß
man nicht, wo in naher Zukunft Datenverkehr entsteht.
1.1
Grundbegriffe
Bei Online-Problemen handelt es sich um eine spezielle Art von Optimierungsproblemen. Im Allgemeinen sagen wir, dass ein Optimierungsproblem (wir betrachten
hier o.b.d.A. nur Minimierungsprobleme) aus einer Menge von Eingaben I und einer
Kostenfunktion C besteht. Für jede Eingabe i ∈ I gibt es eine Menge von zulässigen
Ausgaben (Lösungen) F(i). Mit jeder zulässigen Lösung o ∈ F(i) sind Kosten C(i, o)
assoziiert, die die Kosten für Ausgabe o bei Eingabe i darstellen.
Ein Algorithmus ALG berechnet nun bei Eingabe i ∈ I eine L ösung o ∈ F(i). Die
Kosten von ALG sind dann ALG(i) = C(i, o). Ein optimaler Algorithmus OPT berechnet für jede Eingabe i ∈ I eine Lösung mit den geringsten Kosten
OPT(i) = min C(i, o) .
o∈F(i)
Bei Online-Algorithmen kommt nun noch ein weiterer Aspekt hinzu: Die Eingabe ist
nicht vorab bekannt, sondern sie trifft erst nach und nach als Sequenz ein. Dem OnlineAlgorithmus wird also immer nur das nächste Element der Eingabesequenz präsentiert
ohne dass er die zukünftigen Elemente kennt.
Wir werden nun definieren, wie man die Güte eines Online-Algorithmus bewertet.
Wir sagen, dass ein Online-Algorithmus ALG c-kompetitiv ist, wenn f ür jede Einga-
4
besequenz σ gilt
ALG(σ) ≤ c · OPT(σ) + α ,
wobei α eine Konstante ist, die unabhängig von σ ist. Wenn α = 0 ist, dann ist ALG
streng c-kompetitiv. Die Kompetitiv-Ratio eines Online-Algorithmus ALG bezeichnet
das Infimum über alle Werte c mit der Eigenschaft, dass ALG c-kompetitiv ist.
Eine beliebte Art, Online-Algorithmen zu analysieren, ist, das Problem als Spiel
zwischen dem Online-Algorithmus und einem Gegenspieler zu modellieren. Dabei
kennt der Gegenspieler den Online-Algorithmus und darf die Eingabesequenz bestimmen. Sein Ziel ist es, das Verhältnis zwischen den Kosten des Online-Algorithmus und
seinen Kosten zu maximieren. Das heißt, er wird eine Sequenz wählen, welche die
Kompetitiv-Ratio erreicht.
1.2
Amortisierte Analyse
Wir werden nun eine Analysetechnik anhand einiger Beispiele kennenlernen, die
im Bereich Online-Algorithmen eine große Rolle spielt. Die so genannte amortisierte Analyse wurde ursprünglich zur Analyse von dynamischen Datenstrukturen
eingeführt. Dabei geht man davon aus, dass jede Operation mit einer gewissen Menge
Geld startet. Mit diesem Geld bezahlt man für das Ausführen von Operation und es
ist möglich Geld, das man für eine Operation nicht verbraucht hat, für zukünftige,
unter Umständen teurere, Operationen zu sparen. Man könnte auch sagen, dass man
mit amortisierter Analyse die durchschnittlichen Kosten einer Worst-Case-Eingabe
analysiert.
Im Bereich Datenstrukturen wird die amortisierte Analyse benutzt, um die durchschnittlichen Kosten einer Sequenz σ1 , . . . , σn von Anfragen mit Kosten c1 , . . . , cn zu
analysieren. Dabei gilt:
Worst-Case-Kosten von σ = max ci
i
Gesamtkosten von σ =
∑ ci
i
Amortisierte Kosten von σ =
∑ ci/n
i
Als amortisierte Kosten (von Operationen auf) der Datenstruktur bezeichnet man dann
das Maximum der amortisierten Kosten von σ über alle Folgen σ.
Amortisierte Analyse eines Binärzählers
Wir werden nun amortisierte Analyse anhand des Beispiels eines k-Bit Binärzählers
kennenlernen. Zu Beginn ist ein solcher Zähler mit 0 initialisiert und es gibt nur eine
Operation, nämlich das Erhöhen des Zählers um 1. Dies geschieht, indem man die Bits
5
von rechts nach links durchläuft und flippt, bis man ein Bit von 0 auf 1 geflippt hat.
Die Anzahl der Bitwechsel gibt dabei die Kosten des Erhöhens an.
Offensichtlich gilt, dass die Kosten für das Erhöhen des Zählers im Worst-Case k
sind. Doch was sind die amortisierten Kosten für das Erhöhen des Zählers?
Theorem 1.1 Die amortisierten Kosten für das Erhöhen eines Zählers sind O(1).
Wir werden den obigen Satz nun aus drei verschiedenen Blickwinkeln beweisen.
Aus der Sicht eines Ingenieurs, eines Bankers und eines Physikers.
Sichtweise des Ingenieurs
Die Idee hier ist, dass ganze Problem einfach durchzurechnen. Wir stellen fest, dass
das rechteste Bit b0 jedesmal geflippt wird. Das zweitrechteste Bit b1 wird jedes zweite
mal geflippt. Das Bit bi wird jedes 2i -te mal geflippt. Für m Operationen ergeben sich
amortisierten Kosten
blog mc
∑i=0 b 2mi c
cb =
<2 .
m
Sichtweise des Bankers (Konto Methode)
Bei jeder Operation werden zunächst cb Euro gezahlt. Von diesen cb Euro müssen
zunächst die Kosten der Operation bezahlt werden. Eventuell übrig gebliebenes Geld
kann auf ein Konto eingezahlt werden. Sind die Kosten f ür eine Operation größer als
cb, so müssen diese mit Geld vom Konto bezahlt werden. Dann gilt folgende Beobachtung.
Beobachtung 1.2 Hat ein System immer einen nicht negativen Kontostand, dann ist cb
eine obere Schranke für die amortisierten Kosten des Systems.
Um nun unser Beispiel des Binärzählers zu analysieren, setzen wir cb = 2. Wir
werden für jedes Bit einen eigenen Kontostand einführen. Der Kontostand eines Bits ist
1, wenn der Wert des Bits 1 ist und 0 sonst. Nach der ersten Operation zeigt das kleinste
Bit den Wert 1 und wir haben einen Euro für das flippen gezahlt und den übrigen Euro
auf das Konto des kleinsten Bits gezahlt. Also stimmt unsere Behauptung.
Nehmen wir an, unsere Behauptung stimmt für die ersten m Operationen. In Operation m + 1 werden nun die kleinsten j Bits des Zählers geflippt. Per Definition geschieht dies, wenn die kleinsten j − 1 Bits den Wert 1 gezeigt haben. Wir zahlen das
Flippen der j − 1 Bits von den Konten dieser Bits und das Flippen des j-ten Bit von
unseren 2 Euro für die Operation. Den übrigen Euro zahlen wir auf das Konto von Bit
j ein. Da die letzten j − 1 Bits auf 0 gestellt wurden, durften wir jeweils den Euro abheben. Einen Euro müssen wir einzahlen, weil das j-te Bit auf 1 gesetzt wird. Da wir
diesen Euro eingezahlt haben, stimmt unsere Behauptung auch nach Operation m + 1
und ist damit per Induktion immer korrekt.
6
Sichtweise des Physikers (Potentialfunktion Methode)
Hier wird überschüssige Energie als Potential des gesamten Systems gespeichert. Dieses Potential wird benutzt, um für Operationen zu bezahlen, die mehr Energie kosten
als sie bringen. Das Potential zum Zeitpunkt i wird mit Φi bezeichnet. Sei
Damit gilt
ci + Φi − Φi−1 ≤ cb .
m
m
i=1
i=1
m
m · cb = ∑ cb ≥ ∑ (ci + Φi − Φi−1 ) = ∑ ci + Φn − Φ0 .
i=1
Beobachtung 1.3 Wenn Φm ≥ Φ0 ist, dann ist cb eine obere Schranke für die amortisierten Kosten.
Wir wenden nun die Potential Methode auf unser Binärzähler Problem an. Sei Φi
die Anzahl Bits, die zum Zeitpunkt i auf 1 gesetzt sind. Es gilt Φ m ≥ 0 = Φ0 . Wir
betrachten die m-te Operation. Sei j − 1 die Position des Bits, das auf 1 geflippt wird
(und alle Bits an Positionen kleiner j werden auf 0 geflippt). Dann gilt
Φm − Φm−1 = 1 − ( j − 1) = 2 − j .
Also sind die amortisierten Kosten höchstens
cm + Φm − Φm−1 = j + (2 − j) = 2 .
1.3
Grundlagen der Wahrscheinlichkeitsrechnung
Wahrscheinlichkeitsraum
Ein diskreter Wahrscheinlichkeitsraum ist eine endliche Menge Ω = {ω 1 , . . . , ωn } von
Elementarereignissen ωi .
Eine Wahrscheinlichkeitsverteilung gibt die Wahrscheinlichkeit Pr [ω i ] = pi an.
Dabei muss gelten, dass die Summe der Wahrscheinlichkeiten über alle Elementarereignisse 1 ist, d.h.
∑ Pr [ωi] = 1 ,
ωi ∈Ω
und die Wahrscheinlichkeiten dürfen nicht negativ sein, also
Pr [ωi ] ≥ 0 .
Beispiel 1.4 Sei Ω =
ˆ Würfelergebnis zweier unterscheidbarer Würfel. Dann ist
Ω = {(1, 1), (1, 2), (1, 3, ), (1, 4), (1, 5), (1, 6), (2, 1), (2, 2), . . . , (2, 6), . . . , (6, 6)} .
Da jeder Wurf gleichwahrscheinlich ist, gilt für jedes Elementarereignis a ∈ Ω,
Pr [a] = 1/36 .
7
Ereignis
Eine Menge W ⊆ Ω heißt Ereignis. Die Wahrscheinlichkeit eines Ereignisses W ist
Pr [W ] =
∑
ω∈W
Pr [ω] .
Beispiel 1.5 Im Beispiel zweier Würfel kann man das Ereignis W = Pasch definieren,
also W = {(1, 1), . . . , (6, 6)}. Für diese Ereignis ergibt sich
Pr [W ] = 6 · 1/36 = 1/6 .
Zufallsvariable
Eine Zufallsvariable ist eine Funktion
X :Ω→R .
Offensichtlich bezeichnet der Begriff Zufallsvariable nicht einfach eine Variable im
klassischen Sinne. Viel mehr ist der Wert X vom Ausgang eines Zufallsexperimentes
abhängig und in diesem Sinne eine Variable.
Beispiel 1.6 Im Beispiel Wurf zweier Würfel bezeichnet
X((a, b)) = a + b
die Zufallsvariable für die Summe der beiden Würfel.
Man schreibt auch abkürzend
Pr [X < k]
für
Pr [ω ∈ Ω|X(ω) < k] .
Analog benutzt man auch Pr [X = k] und Pr [X > k].
Erwartungwert
Der Erwartungswert einer Zufallsvariable gibt den durchschnittlichen Wert an, den
eine Zufallsvariable annimmt. Der Erwartungswert E [X] einer Zufallsvariable X ist
definiert als
E [X] = ∑ k · Pr [X = k] .
k∈X(Ω)
Beispiel 1.7 Wir betrachten noch einmal das Werfen von zwei W ürfeln und die Zufallsvariable X für die Summe der beiden Würfel. Wir bekommen:
E [X] = 2 · 1/36 + 3 · 1/18 + 4 · 1/12 + · · · + 12 · 1/36 = 7 .
8
Linearität des Erwartungswertes
Die Linearität des Erwartungswertes ist eine der wichtigsten Eigenschaften, die wir
bei der Analyse randomisierter Algorithmen ausnutzen. Seien X1 , . . . , Xn Zufallsvariablen auf Ω. Dann gilt
"
#
n
∑ Xi
E
i=1
wobei
Ã
n
n
= ∑ E [Xi ] ,
i=1
!
n
∑ Xi (ω) = ∑ Xi(ω)
i=1
i=1
bezeichnet. Linearität des Erwartungswertes bedeutet also, dass der Erwartungswert
einer zusammengesetzten“ Zufallsvariable bestimmt werden kann, indem man sie als
”
Summe einfacherer“ Zufallsvariablen schreibt und für diese einfachen Zufallsvaria”
blen ihren Erwartungswert bestimmt. Die Summe des Erwartungswertes der einfachen
Zufallsvariablen ist dann der Erwartungswert der zusammengesetzten Zufallsvariable.
9
Kapitel 2
List-Accessing
Als erstes werden wir uns mit dem List-Accessing-Problem beschäftigen. Dabei nehmen wir an, dass ` Datensätze in einer verketteten Liste abgespeichert sind. Zu jedem
Datensatz gibt es einen Schlüssel. Datensätze könnten z.B. Kundendaten sein und der
Schlüssel ist der Kundenname.
Zugegriffen wird auf die Datensätze wie folgt: Die Liste wird von vorne nach hinten durchgesehen, bis man auf den Datensatz trifft bzw. weiß, dass der Datensatz nicht
in der Liste vorhanden ist. Wir nehmen an, dass wir für eine solche Operation x Schritte benötigen, wobei x die Position des Datensatzes in der Liste ist. Neue Datensätze
können in die Liste eingefügt werden und Datensätze können auch gelöscht werden.
Das Einfügen eines Datensatzes kostet ` + 1 Zeitschritte, wobei ` die Länge der Liste vor Einfügen des Datensatzes ist. Das Löschen des x-ten Datensatzes in der Liste
kostet x Zeitschritte.
Bisher haben wir eine Implementierung (durch verkettete Listen) des abstrakten
Datentyps Wörterbuch beschrieben. Die Implementierung durch verkettete Listen ist
sehr einfach und wird daher häufig für Wörterbücher moderater Größe genutzt.
Aber wo ist nun ein Online-Problem versteckt?
Nach einem Zugriff oder dem Einfügen bzw. Löschen eines Datensatzes in der
Liste ist es erlaubt, die Liste neu zu organisieren. Wir messen die Kosten zur Reorganisation der Liste in Transpositionen (Vertauschungen benachbarter Elemente). Es gibt
jedoch eine Sonderregel: Einen Datensatz, auf den gerade zugegriffen wurde, d ürfen
wir kostenlos näher zum Listenanfang verschieben. Die Idee ist hier, dass wir bei der
Suche nach diesem Datensatz Zeiger zu den bisher besuchten Positionen aufrecht erhalten können. Alle anderen Transpositionen sind kostenpflichtig: Sie kosten einen
Zeitschritt.
Damit haben wir folgendes Online-Problem: Beim List-Accessing-Problem ist ein
Online-Algorithmus gesucht, der die Liste nach jedem Zugriff geschickt reorganisiert,
so dass die Gesamtzugriffszeit minimiert wird.
In unserer Beschreibung haben wir ein dynamisches Problem beschrieben – wir
haben das Einfügen und Löschen von Datensätzen erlaubt. Eine andere Variante des
10
Problems ist das statische List-Accessing-Problem. Dabei sind nur Zugriffsoperationen
erlaubt.
2.1
Der Algorithmus Move-To-Front
Der deterministische Algorithmus Move-To-Front (MTF) ist sehr einfach: Nach jedem
Zugriff auf einen Datensatz oder dem Einfügen eines Datensatzes bewegen wir diesen
an die erste Position der Liste, ohne die relative Ordnung der anderen Elemente zu
verändern. Wir werden nun zeigen, dass MTF eine Kompetitiv-Ratio von 2 erreicht.
Theorem 2.1 MTF ist 2-kompetitiv.
Beweis. Wir müssen zeigen, dass für jede beliebige Sequenz von Operationen σ =
σ1 · · · σn (Zugriff, Einfügen, Löschen) MTF höchstens doppelt so viele Zeitschritte
benötigt wie ein optimaler Offline-Algorithmus OPT. Wir stehen nun vor einem Problem: Im Gegensatz zum Ski-Rental Problem kennen wir keine einfache Beschreibung
einer optimalen Offline-Strategie. Wie können wir dann jedoch eine Aussage über die
Kompetitiv-Ratio machen?
Wir werden eine Potentialfunktion Φi benutzen, die die Konfiguration von MTF
und OPT beschreibt, nachdem Operation σi bearbeitet worden ist. Der Wert von Φi
ist die Anzahl der Inversionen in der Liste von MTF bezüglich der Liste von OPT,
dabei ist eine Inversion ein geordnetes Paar von Datensätzen hx, yi, wobei x vor y in
der Liste von MTF steht, aber x nach y in der Liste von OPT steht. Wir bezeichnen mit
off
con
i die Kosten von MTF für die i-te Operation und mit ci die entsprechenden Kosten
von OPT. Wir wollen zeigen, dass für die amortisierten Kosten von MTF für die i-te
Operation gilt:
off
.
ai = con
i + Φi − Φi−1 ≤ 2 · ci
Im Unterschied zu unseren bisherigen Beispielen können die amortisierten Kosten für
die einzelnen Operationen verschieden sein.
Wir wollen nun zeigen, dass die amortisierten Kosten für die i-te Operation
höchstens (2s − 1) + P − F betragen. Dabei bezeichnet s die Suchkosten, P die Anzahl
kostenpflichtiger Transpositionen und F die Anzahl kostenloser Transpositionen von
OPT bei der Bearbeitung der i-ten Anfrage.
Wir betrachten zunächst nur Zugriffsoperationen. Zuerst werden wir die Kosten
analysieren, die MTF verursacht, und danach werden wir die Kosten analysieren, die
OPT verursacht. Sei x der Datensatz, auf den zugegriffen werden soll. Sei j die Position
von x in der Liste von OPT und k die Position in der Liste von MTF. Weiterhin sei v
die Anzahl der Datensätze, die in der Liste von MTF vor x stehen, aber in der Liste
von OPT hinter x stehen. Dann gibt es k − 1 − v Datensätze, die in beiden Listen vor x
liegen. Außerdem gilt k − 1 − v ≤ j − 1, da x an Position j in der Liste von OPT steht.
Also gilt k − v ≤ j.
11
Bewegt MTF nun x an die erste Position der Liste, so erzeugt er k − 1 − v neue
Inversionen bezüglich der Liste von OPT. Desweiteren eliminiert diese Aktion auch
v Inversionen bezüglich der Liste von OPT. Also ist der Beitrag zu den amortisierten
Kosten
k + (k − 1 − v) − v = 2(k − v) − 1 ≤ 2 j − 1 = 2s − 1 .
Die Suche von OPT beeinflusst die Potentialfunktion und damit die amortisierten
Kosten nicht. Jede bezahlte Transposition von OPT erhöht das Potenzial höchstens um
1, jede Transposition, die umsonst ist, verringert es um 1. Daraus folgt sofort, dass gilt
ai ≤ (2s − 1) + P − F ≤ 2(s + P) = 2 · coff
.
i
Insgesamt ergibt sich für die Kosten von MTF
n
n
n
i=1
i=1
i=1
off
MTF(σ) = ∑ con
i = ∑ ai + Φ0 − Φn ≤ 2 ∑ ci = 2 · OPT(σ) ,
da Φn ≥ 0 und Φ0 = 0 ist (die Listen von MTF und OPT sind zu Beginn identisch).
Um dasselbe Ergebnis für das Einfügen eines Datensatzes oder den Zugriff auf
nicht vorhandene Datensätze zu zeigen, können wir die gleichen Argumente verwenden und müssen lediglich j = ` + 1 setzen, wobei ` die Länge der Listen bezeichnet.
Der Fall, dass ein Datensatz gelöscht wird ist noch einfacher, da hier keine neuen Inversionen erzeugt werden und somit der Beitrag von MTF zu den amortisierten Kosten
k − v ≤ j = s ≤ 2s − 1 ist.
2.2
Deterministische untere Schranke
Wir werden nun eine untere Schranke für deterministische Online-Algorithmen bzgl.
des List-Accessing-Problems zeigen. Dabei beschränken wir uns auf das statische Modell. Da das statische Modell ein Spezialfall des dynamischen Modells ist, gilt diese
Schranke natürlich auch für den dynamischen Fall. Wir werden folgenden Satz beweisen.
Theorem 2.2 Ein jeder deterministische Online-Algorithmus f ür das statische List2
Accessing-Problem hat eine Kompetitiv-Ratio von mindestens 2 − `+1
, wobei ` die
Anzahl der Datensätze in der Liste bezeichnet.
Beweis. Sei eine Liste der Länge ` gegeben. Wir werden nun einen so genannten grausamen Gegenspieler einsetzen. Dieser Gegenspieler fragt immer den Datensatz an,
der am Ende der Liste steht. Er maximiert also die Kosten des Online-Algorithmus.
Nehmen wir einmal an, dass die Länge der Anfragesequenz n ist. Dann sind die Gesamtkosten des Online-Algorithmus ` · n.
Wie können wir nun zeigen, dass es einen Offline-Algorithmus gibt, der diese Anfragesequenz besser bearbeiten kann. Dazu werden wir uns eine Menge von OfflineAlgorithmen definieren und berechnen, wieviel Zeit diese im Durchschnitt brauchen,
12
um die Anfragesequenz zu bearbeiten. Danach benutzen wir, dass es mindestens einen
Offline-Algorithmus geben muss, der genauso gut ist wie der Durchschnitt.
Wir betrachten `! verschiedene Offline-Algorithmen. Jeder dieser Algorithmen
entspricht einer der `! Permutationen der Liste. Genauer gesagt, ordnet ein solcher
Offline-Algorithmus zu Beginn die Liste entsprechend dieser Permutation an und
verändert die Ordnung der Liste danach nicht mehr. Das heißt, die Kosten f ür einen
solchen Offline Algorithmus bestehen aus den Kosten für diese Umordnung plus den
Kosten für das beantworten der Anfragen. Die Kosten für die Umordnung sind O(`2 )
(Bubblesort), also eine Konstante, da ` nicht von n abhängt.
Nun berechnen wir die durchschnittlichen Zugriffskosten eines dieser `! OfflineAlgorithmen. Dazu müssen wir die Gesamtkosten aller Algorithmen berechnen und
durch `! teilen.
Um die Gesamtkosten zu berechnen, machen wir folgende Beobachtung. Wenn wir
einen Zugriff auf einen Datensatz x haben, dann kann x an jeder beliebigen Position
der Liste stehen. Wenn wir nun festhalten, dass x an Position i steht, dann gibt es f ür
die übrigen Position noch (` − 1)! Möglichkeiten und die Kosten für die Anfrage von
x sind i. Daher gilt, dass die Gesamtkosten für eine Anfrage von x genau
`
∑ i · (` − 1)! = (` − 1)! ·
i=1
` · (` + 1)
2
sind. Damit sind die Gesamtkosten für alle n Anfragen
n··
(` + 1)!
+ `! · O(`2 ) .
2
Es ergeben sich also Durchschnittkosten von
1
n(` + 1) + O(`2 ) .
2
Daher gibt es auch einen Offline-Algorithmus, der höchstens diese Kosten hat. Für n →
∞ strebt das Verhältnis zwischen Online-Kosten und Offline-Kosten gegen 2`/(` + 1).
13
Kapitel 3
Selbstanpassende Suchbäume
Im vorherigen Kapitel haben wir die einfache Datenstruktur verkettete Liste f ür
ein Wörterbuch kennengelernt. Solch eine verkettete Liste ist jedoch keine effiziente Implementierung eines Wörterbuchs. Daher betrachten wir nun Suchbäume. Für
Suchbäumen ist leider eine (nichttriviale) Kompetitive-Analyse noch nicht bekannt.
Allerdings werden wir in einem etwas vereinfachten Modell ein erstaunliches Ergebnis
zeigen: Es gibt Suchbäume, die bei einer beliebigen Anfragesequenz σ asymptotisch
genausogut sind wie ein optimalen statischer Suchbaum für σ.
Eine Klasse von Suchbäumen mit dieser Eigenschaft sind die so genannten SplayBäume. Diese benutzen die SPLAY-Operation mit deren Hilfe ein Element des Suchbaumes an die Wurzel rotiert wird. Dabei sorgen die Rotationen daf ür, dass der Suchbaum auf lange Sicht balanciert wird.
y
x
x
A
C
y
A
B
B
C
Abbildung 3.1: Beispiel für eine Rotation
Die Kosten einer Operation entspricht der Anzahl der Vergleiche, die notwendig
sind, um das entsprechende Element im Suchbaum zu finden, oder um festzustellen,
dass das entsprechende Element nicht im Suchbaum vorhanden ist. Die Kosten f ür die
Reorganisation des Suchbaumes werden in der Anzahl der daf ür notwendigen Rotationen gemessen. Es gibt jedoch eine Sonderregel: Ein Element, auf das gerade zugegriffen wurde, darf umsonst aufwärts rotiert werden. Die Idee dabei ist, dass bei der
Suche nach dem entsprechenden Element Zeiger zu den bisher besuchten Positionen
aufrecht erhalten werden können.
14
3.1
Operationen auf Splay-Bäume
Folgende Operationen werden von Splay-Bäumen zur Verfügung gestellt.
• SPLAY(x): Dies ist die wichtigste Operation. Mit ihrer Hilfe werden alle anderen Operationen implementiert. Eine SPLAY-Operation holt das Element x mit
Hilfe von Rotationen an die Wurzel des Suchbaumes. Ist das Element x nicht
im Suchbaum vorhanden, so wird der Vorgänger oder Nachfolger von x an die
Wurzel rotiert.
• ACCESS(x): Auf das Element x wird zugegriffen. Diese Operation wird durch
SPLAY(x) und Ausgabe der Wurzel realisiert.
• INSERT(x): Beim Einfügen eines Elements wird zunächst eine SPLAY(x)Operation durchgeführt. Diese rotiert den Vorgänger oder Nachfolger von x an
die Wurzel.
Ist nun die Wurzel r der Nachfolger von x, so wird x Wurzel des neuen Suchbaumes. Der linke Teilbaum von r wird zum linken Nachfolger von x und r wird
rechter Nachfolger von x. Ist die Wurzel r der Vorgänger von x, so erfolgt das
Einfügen analog.
• DELETE(x): Um ein Element x aus dem Splay-Baum zu löschen wird dieses zunächst mit der SPLAY(x)-Operation an die Wurzel geholt. Dann wird es
gelöscht und die beiden dabei entstehenden Bäume werden mit Hilfe von der
JOIN-Operation wieder zusammengefügt.
• JOIN(T1 , T2 ): Die JOIN Operation vereinigt zwei Bäume T1 und T2 unter der
Voraussetzung, dass die Elemente in T1 alle kleiner sind als die Elemente in
T2 . Bei einem JOIN wird zunächst ein SPLAY(∞) in Baum T1 durchgeführt.
Damit wird das größte Element aus Baum T1 an die Wurzel rotiert und der rechte
Teilbaum unter der Wurzel ist leer. Dort wird nun Baum T2 angehängt.
• SPLIT(x): Auch bei der SPLIT Operation wird zunächst ein SPLAY(x) durchgeführt. Danach sind alle Elemente im linken Unterbaum der Wurzel kleiner als
x und alle Elemente im rechten Unterbaum größer. Je nachdem, ob die Wurzel kleiner (oder gleich) oder größer als x ist, bleibt sie Wurzel des linken bzw.
rechten Teilbaums.
Wir können also jede Operation mit Hilfe zweier SPLAY-Operationen und eines konstanten Zusatzaufwandes durchführen. Daher interessiert uns im folgenden in erster
Linie die SPLAY-Operation.
Bei einer SPLAY(x)-Operation wird zunächst das Element x im Baum gesucht.
Ist das Element x nicht im Baum vorhanden, so wird der Vorgänger oder Nachfolger
von x mit x identifiziert. Dann wird x mit Hilfe von Rotationen an die Wurzel des
Baumes bewegt. Dabei unterscheiden wir je nach Baumstruktur zwischen drei Fällen,
die jeweils auch gespiegelt auftreten können.
15
1. Ist x ein Kind der Wurzel des Suchbaumes, so wird es mit Hilfe einer Rotation
höher bewegt.
y
x
x
C
A
y
A
B
B
C
Abbildung 3.2: Fall 1
2. Ist x auf dem linken Grat des Suchbaumes, so wird es mit Hilfe zweier Rotationen (erst um z, dann um y) höher bewegt.
z
x
y
D
x
C
A
y
A
z
B
B
C
D
Abbildung 3.3: Fall 2
3. Ansonsten kann noch folgender Fall auftreten. x wird mit Hilfe zweier Rotationen (erst um y, dann um z) höher bewegt.
z
x
y
A
x
B
z
D
A
C
y
B
C
D
Abbildung 3.4: Fall 3
3.2
Analyse der SPLAY-Operation
Wir wollen nun die amortisierten Kosten von SPLAY(x) analysieren. Dazu f ühren wir
eine Potentialfunktion Φ ein, die uns das Potential eines Splay-Baumes T angibt. Wir
nehmen an, dass jeder Knoten x ein positives Gewicht w(x) besitzt (zunächst setzen wir
w(x) = 1; später werden wir jedoch auch andere Gewichte betrachten). Dann k önnen
16
wir das Gewicht eines Teilbaumes definieren, wobei wir einen Teilbaum mit seiner
Wurzel identifizieren:
∑
W (x) =
w(y) .
Knoten y im Teilbaum von x
Der Rang r(x) von x ist dann
r(x) = log2 W (x) .
Letztendlich könne wir dann das Potential eines Splay-Baumes T definieren:
∑
Φ(T ) =
r(x) .
Knoten x in T
Betrachten wir nun eine Sequenz σ = σ1 · · · σm von Operationen. Die amortisierten
Kosten ai von Operation σi sind die tatsächlichen Kosten ci von σi plus die Potentilaveränderung, die durch σi verursacht worden ist. Im vorherigen Kapitel haben wir
schon gesehen, dass dann die tatsächlichen Kosten der Sequenz σ höchstens die amortisierten Kosten von σ plus das Anfangspotential der Datenstruktur sind, d.h.:
m
m
i=1
i=1
∑ ci ≤ ∑ ai + Φ(T )
,
wobei T der initiale Suchbaum ist. Als erstes wollen wir nun die amortisierten Kosten
einer SPLAY-Operation analysieren.
Lemma 3.1 Die amortisierten Kosten von SPLAY(x) betragen höchstens 1 + 3(r(t) −
r(x)), wobei t die Wurzel des Baumes vor der Operation ist.
Beweis. Wir teilen die SPLAY-Operation in eine Sequenz von Schritten auf. Dabei
ist jeder Schritt gerade einer der drei oben beschriebenen Fälle, die bei einer SPLAYOperation auftreten können. Wir betrachten nun per Fallunterscheidung die amortisierten Kosten eines Schrittes. Dabei bezeichnet r(y) den Rang von einem Knoten y vor
dem Schritt und r 0 (y) den Rang von y nach dem Schritt.
x
y
x
A
C
y
A
B
B
C
Abbildung 3.5: Fall 1
Behauptung 3.2 Im Fall 1 betragen die amortisierten Kosten h öchstens 1 + 3(r 0 (x) −
r(x)).
17
Beweis. Weil eine Rotation benötigt wird, betragen die amortisierten Kosten
1 + r0 (x) + r0 (y) − r(x) − r(y) = 1 + r0 (y) − r(x) ,
da r0 (x) = r(y) ist. Weil r 0 (y) ≤ r0 (x) ist, folgt
1 + r0 (y) − r(x) ≤ 1 + r0 (x) − r(x) .
Da r0 (x) ≥ r(x) ist, folgt dann
1 + r0 (x) − r(x) ≤ 1 + 3(r0 (x) − r(x)) .
z
x
y
x
A
D
y
A
C
z
B
B
C
D
Abbildung 3.6: Fall 2
Behauptung 3.3 Im Fall 2 betragen die amortisierten Kosten h öchstens 3(r0 (x) −
r(x)).
Beweis. Weil zwei Rotationen benötigt werden, betragen die amortisierten Kosten
2 + r0 (x) + r0 (y) + r0 (z) − r(x) − r(y) − r(z) = 2 + r 0 (y) + r0 (z) − r(x) − r(y) ,
da r0 (x) = r(z) ist. Weil r 0 (x) ≥ r0 (y) und −r(x) ≥ −r(y) ist, folgt
2 + r0 (y) + r0 (z) − r(x) − r(y) ≤ 2 + r0 (x) + r0 (z) − 2r(x) .
Wir zeigen nun, dass
r0 (z) + r(x) − 2r0 (x) ≤ −2
ist. Damit folgt dann, dass gilt
2 + r0 (x) + r0 (z) − 2r(x) ≤ 3(r0 (x) − r(x)) .
Wir setzen nun r 0 (z) = log2 W 0 (z) und r0 (x) = log2 W 0 (x) ein und erhalten
Es gilt
r0 (z) + r(x) − 2r0 (x) = log2 W 0 (z) + log2 W (x) − 2 log2 W 0 (x)
µ
µ 0 ¶
¶
W (x)
W (z)
+ log2
.
= log2
W 0 (x)
W 0 (x)
µ
µ
¶
¶
W 0 (z)
W (x)
log2
+ log2
≤ −2 ,
W 0 (x)
W 0 (x)
da links ein Term der Form log a + log b steht, mit 0 ≤ a, b ≤ 1 und a + b ≤ 1, da
W 0 (z) + W (x) ≤ W 0 (x) ist, und dieser Term log a + log b nimmt sein Maximum für
a = b = 1/2 an.
18
z
x
y
A
x
B
z
D
A
C
y
B
C
D
Abbildung 3.7: Fall 3
Behauptung 3.4 Im Fall 3 betragen die amortisierten Kosten h öchstens 3(r0 (x) −
r(x)).
Beweis. Weil zwei Rotationen benötigt werden, betragen die amortisierten Kosten
2 + r0 (x) + r0 (y) + r0 (z) − r(x) − r(y) − r(z) ≤ 2 + r 0 (y) + r0 (z) − 2r(x) ,
da r0 (x) = r(z) und −r(x) ≥ −r(y) ist.
Wir zeigen nun, dass
r0 (z) + r0 (y) − 2r0 (x) ≤ −2
ist. Damit folgt dann, dass gilt
2 + r0 (y) + r0 (z) − 2r(x) ≤ 2(r0 (x) − r(x)) ≤ 3(r0 (x) − r(x)) ,
da r0 (x) ≥ r(x) ist. Wir setzen nun r 0 (z) = log2 W 0 (z), r0 (y) = log2 W 0 (y) und r0 (x) =
log2 W 0 (x) ein und erhalten
r0 (z) + r0 (y) − 2r0 (x) = log2 W 0 (z) + log2 W 0 (y) − 2 log2 W 0 (x)
µ 0 ¶
µ 0 ¶
W (y)
W (z)
+ log2
.
= log2
0
W (x)
W 0 (x)
Es gilt
log2
µ
µ 0 ¶
¶
W 0 (z)
W (y)
+ log2
≤ −2 ,
0
W (x)
W 0 (x)
da links ein Term der Form log a + log b steht, mit 0 ≤ a, b ≤ 1 und a + b ≤ 1, da
W 0 (z) + W 0 (y) ≤ W 0 (x) ist, und dieser Term log a + log b nimmt sein Maximum für
a = b = 1/2 an.
Nun beobachten wir noch, dass Fall 1 bei einer SPLAY-Operation nur ein einziges
mal auftritt. Dann folgt mit Hilfe der Teleskopsummenregel, dass die amortisierten
einer SPLAY(x)-Operation höchstens 1 + 3(r(t) − r(x)) betragen, wobei t die Wurzel
des Baumes vor der Operation ist.
Wir können nun folgenden Satz zeigen.
19
Theorem 3.5 Eine Sequenz σ = σ1 · · · σm von Operationen wird auf einem SplayBaum, der dabei maximal Größe n erreicht, in Zeit O((m + n) log n) abgearbeitet.
Beweis. Sei T der Suchbaum vor der ersten Operation. Wir wissen, dass T h öchstens
n Knoten hat. Wir setzen für jeden Knoten x sein Gewicht w(x) = 1. Damit folgt,
dass Φ(T ) = O(n log n) ist. Nach Lemma 3.1 gilt, dass die amortisierten Kosten einer
SPLAY-Operation höchstens O(1 + r(t)) = O(log n) betragen, wobei t die Wurzel des
Baumes vor der Operation ist. Da die amortisierten Kosten plus Anfangspotential eine
obere Schranke für die tatsächlichen Kosten sind, folgt der Satz.
3.3
Statische Optimalität von Splay-Bäumen
Wir werden nun zeigen, dass Splay-Bäume asymptotisch so gut sind, wie ein beliebiger
statischer Suchbaum (der Suchbaum wird während der Anfragen nicht verändert). Wir
können also auch den statischen Suchbaum nehmen, der optimal f ür eine feste Folge
von Anfragen ist, und dieser optimale statische Suchbaum wäre asymptotisch nicht
besser als ein Splay-Baum.
Theorem 3.6 Sei S eine Menge von n Elementen und σ eine Sequenz von Zugriffsoperationen auf Elemente aus S. Desweiteren sei TS ein beliebiger statischer Suchbaum
für die Elemente aus S und ` die Anzahl Vergleiche, die benötigt werden, um σ auf TS
abzuarbeiten. Dann wird σ auf einem Splay-Baum in Zeit O(` + n 2 ) abgearbeitet.
Beweis. Sei T ein beliebiger Splay-Baum für S und t die Wurzel von T . Sei d die Tiefe
von TS und d(x) die Länge des Pfades von der Wurzel von TS zu x. Wir verwenden nun
für jeden Knoten x aus T die Gewichtsfunktion
w(x) = 3d−d(x) .
Wir zeigen zunächst folgende Behauptung.
Behauptung 3.7 W (t) ≤ 3d+1 .
Beweis. Man kann beobachten, dass das Gewicht der Wurzel t maximal f ür einen
vollständigen Binärbaum B ist. Damit ergibt sich
W (t) =
∑ w(x) = ∑ 3
x∈S
x∈S
d−d(x)
d
≤ ∑2 ·3
i
d−i
i=0
20
µ ¶i
2
1
=3 ∑
= 3d+1 .
≤ 3d
3
1
−
2/3
i=0
d
d
Aus Lemma 3.1 folgt dann, dass für die amortisierten Kosten von SPLAY(x) gilt
µ
¶
¶
µ
W (t)
3d+1
O(1 + r(t) − r(x)) = O 1 + log2
= O 1 + log2 d−d(x) = O(1 + d(x)) .
W (x)
3
Für das Potential Φ(T ) gilt
Φ(T ) =
∑ r(x) = ∑ log2 W (x) ≤ ∑ log2 3d+1 = ∑ O(d) = O(n · d) = O(n2)
x∈S
x∈S
.
x∈S
x∈S
Da die amortisierten Kosten plus Anfangspotential eine obere Schranke f ür die
tatsächlichen Kosten sind, folgt der Satz.
21
Kapitel 4
Paging
Beim Paging-Problem geht es darum, dass wir einen Rechner haben, der eine gewisse Menge an schnellem Speicher (z.B. Cache) zur Verfügung hat. Außerdem gibt es
einen langsamen Sekundärspeicher (z.B. Hauptspeicher), der eine größere Speicherkapazität hat. Wir messen die Speicherkapazität in Seiten, und wir nehmen an, dass
unser schneller Speicher Platz für k Seiten hat.
Wenn nun eine Seite angefragt wird, so muss das System diese Seite im schnellen
Speicher bereit stellen. Ist diese Seite nicht im schnellen Speicher vorhanden, dann tritt
ein Seitenfehler auf, d.h. die Seite muss aus dem langsamen Speicher nachgeladen werden und gegebenenfalls muss eine andere Seite aus dem schnellen Speicher verdrängt
werden. Ein Online-Algorithmus muss entscheiden, welche Seite verdrängt wird, ohne
die zukünftigen Anfragen zu kennen. Das Ziel ist es, die Anzahl der Seitenfehler zu
minimieren.
4.1
Ein optimaler Offline-Algorithmus
Zunächst werden wir die Offline-Variante des Paging-Problems betrachten. Im Gegensatz zum List-Accessing-Problem werden wir hier einen einfachen optimalen OfflineAlgorithmus kennenlernen.
• Longest-Forward-Distance (LFD): LFD verdrängt diejenige Seite, deren nächster Zugriff am weitesten in der Zukunft liegt.
Theorem 4.1 LFD ist ein optimaler Offline-Algorithmus f ür das Paging-Problem.
Beweis. Wir zeigen, dass jeder optimale Offline-Algorithmus OPT in LFD umgeformt
werden kann, ohne dass zusätzliche Kosten auftreten. Die Umformung wird iterativ
durchgeführt.
Lemma 4.2 Sei ALG ein beliebiger Paging-Algorithmus und sei σ eine Anfragesequenz. Dann gibt es einen Offline-Algorithmus ALGi mit den folgenden Eigenschaften:
22
• ALGi verhält sich bei den ersten i − 1 Anfragen genauso wie ALG.
• ALGi verhält sich bei der i-ten Anfrage wie LFD.
• ALGi (σ) ≤ ALG(σ).
Beweis. Für einen gegebenen Algorithmus ALG werden wir nun einen Algorithmus
ALGi konstruieren. Für die ersten i Anfragen ist ALGi schon definiert. Wir nehmen
an, dass ALG und ALGi nach der i-ten Anfrage die Seiten X ∪ {v} bzw. X ∪ {u} im
schnellen Speicher haben, wobei X eine Menge von k − 1 Seiten ist. Gilt nun u = v, so
folgt das Lemma sofort. Wir nehmen daher an, dass u 6= v ist.
Solange bei den restliche Anfragen nicht die Seite v verlangt wird, verhält sich
ALGi wie ALG, bis auf den Fall, dass ALGi die Seite u verdrängt, wenn ALG die
Seite v verdrängt. Dies ist möglich, da die Anzahl der gemeinsamen Seiten immer
mindestens k − 1 ist. Wenn die Anzahl der gemeinsamen Seiten sogar k ist, d.h. ALG
verdrängt die Seite v, dann ist von diesem Zeitpunkt an ALGi mit ALG identisch, und
das Lemma folgt.
Wird v angefragt, bevor ALGi mit ALG identisch ist, so hat ALGi einen Seitenfehler und ALG nicht. Da v aber entsprechend LFD verdrängt wurde, muss nach der i-ten
Anfrage Seite u mindestens einmal angefragt worden sein. Die erste solche Anfrage
verursacht einen Seitenfehler bei ALG aber keinen bei ALGi . Daher ist die Gesamtanzahl der Seitenfehler von ALGi höchstens so groß wie die von ALG. Um die Anfrage
bzgl. v zu bedienen, verdrängt ALGi die Seite u, und damit ist von diesem Zeitpunkt
an ALGi mit ALG identisch, und das Lemma folgt.
Der Satz wird dann wie folgt bewiesen: Das obige Lemma wird auf einen optimalen Offline-Algorithmus OPT mit i = 1 angewandt, und man erhält OPT1 . Dann wir
das obige Lemma auf OPT1 mit i = 2 angewandt, und man erhält OPT2 . Dieses wird
wiederholt, bis man einen optimalen Offline-Algorithmus erhält, der sich wie LFD
verhält.
4.2
Deterministische Algorithmen
Im folgenden werden deterministische Online-Algorithmen f ür das Paging-Problem
vorgestellt und einige davon werden analysiert. Alle Strategien verdrängen natürlich
nur dann eine Seite im schnellen Speicher, wenn eine Seite angefragt wird, die nicht
im schnellen Speicher vorhanden ist.
• Least-Recently-Used (LRU): LRU verdrängt diejenige Seite, deren letzter Zugriff am längsten zurückliegt.
• Least-Frequently-Used (LFU): LFU verdrängt diejenige Seite, die am seltensten
angefragt wurde, seit sie im schnellen Speicher ist.
• First-In-First-Out (FIFO): FIFO verdrängt diejenige Seite, die sich am längsten
im schnellen Speicher befindet.
23
• Last-In-First-Out (LIFO): LIFO verdrängt diejenige Seite, die als letztes in den
schnellen Speicher geladen wurde.
4.2.1 Nicht-kompetitive Algorithmen
Ein Online-Algorithmus wird als kompetitiv bezeichnet, falls er eine KompetitiveRatio hat, die nicht von der Länge der Eingabesequenz abhängt. Wir werden nun zeigen, dass LIFO und LFU nicht kompetitive sind.
Theorem 4.3 LIFO ist nicht kompetitive.
Beweis. Sei ` eine positive ganze Zahl. Wir betrachten die Sequenz
σ = p1 , . . . , pk , (pk+1 , pk )` .
LIFO macht bei jeder Anfrage nach den ersten k Anfragen einen Seitenfehler. OPT
hingegen behält einfach die Seiten pk und pk+1 im schnellen Speicher und macht gar
keinen Seitenfehler mehr. Da man ` beliebig groß machen kann, ist LIFO nicht kompetitive.
Theorem 4.4 LFU ist nicht kompetitive.
Beweis. Sei ` eine positive ganze Zahl. Wir betrachten die Sequenz
σ = p`1 , . . . , p`k−1 , (pk , pk+1 )`−1 .
LFU macht bei jeder Anfrage nach den ersten (k − 1) · ` Anfragen einen Seitenfehler.
OPT hingegen macht nur einen einzigen Seitenfehler. Da man ` beliebig groß machen
kann, ist LFU nicht kompetitive.
4.2.2 Marking-Algorithmen
Sei σ eine Anfragesequenz. Wir teilen σ wie folgt in k-Phasen auf: Phase 0 ist die
leere Sequenz zu Beginn von σ. Phase i > 0 ist die maximale Sequenz, die direkt auf
Phase i − 1 folgt, und in der auf höchstens k verschiedenen Seiten zugegriffen wird.
Wir erinnern uns, dass k die Größe des schnellen Speichers bezeichnet.
Ein Marking-Algorithmus assoziieren mit jeder Seite im schnellen Speicher ein
Bit, das angibt, ob die jeweilige Seite markiert oder unmarkiert ist. Zu Beginn einer
k-Phase werden alle Markierungen gelöscht. Während einer k-Phase wird eine Seite
markiert, wenn auf sie zugegriffen wird. Ein Marking-Algorithmus ist nun dadurch gekennzeichnet, dass er niemals markierte Seiten aus dem schnellen Speicher verdrängt.
Theorem 4.5 Jeder Marking-Algorithmus ALG ist k-kompetitiv.
24
Beweis. Wir zeigen zunächst, dass ALG höchstens k Seitenfehler pro Phase macht.
Dieses folgt sofort, da jede Seite nach ihrem ersten Zugriff markiert ist und somit
nicht mehr aus dem schnellen Speicher entfernt wird. Also kann ALG h öchstens einen
Fehler pro unterschiedlicher Seite in einer Phase machen.
Nun zeigen wir, dass OPT pro Phase (bis auf die letzte Phase) mindestens einen
Seitenfehler macht. Sei q die erste Anfrage in Phase i. Wir betrachten die Sequenz, die
mit der zweiten Anfrage von Phase i beginnt und bis einschließlich zur ersten Anfrage
der Phase i + 1 reicht. Zu Anfang dieser Sequenz hat OPT die Seite q und k − 1 andere
Seiten im schnellen Speicher. In dieser Sequenz gibt es Zugriffe auf k verschiedenen
Seiten, die alle ungleich q sind. Also hat OPT mindestens einen Seitenfehler pro Phase
(bis auf die letzte Phase).
Also folgt
ALG(σ) ≤ k · (OPT(σ) + 1) = k · OPT(σ) + k .
Um nun zu zeigen, dass LRU k-kompetitive ist, beweisen wir, dass LRU ein
Marking-Algorithmus ist.
Theorem 4.6 LRU ist ein Marking-Algorithmus.
Beweis. Annahme: LRU ist kein Marking-Algorithmus. Dann verdrängt LRU während
einer Phase eine markierte Seite x. Wir betrachten den ersten Zugriff auf x in dieser
Phase. Hier wird x markiert und x ist zu diesem Zeitpunkt nat ürlich die Seite, auf die als
letztes zugegriffen wurde. Zum Zeitpunkt, wenn LRU x verdrängt, ist x die Seite, deren
Zugriff am längsten zurück liegt. Damit wurden alle k Seiten im schnellen Speicher
und die Seite, die den Seitenfehler verursacht, in einer Phase angefragt. Dieses sind
aber k + 1 verschiedene Seiten, was ein Widerspruch ist. Also ist LRU ein MarkingAlgorithmus.
Korollar 4.7 LRU ist k-kompetitive.
4.2.3 Deterministische untere Schranke
Die folgende untere Schranke zeigt, dass Marking-Algorithmen optimal sind.
Theorem 4.8 Jeder deterministische Paging-Algorithmus ALG hat eine KompetitiveRatio von mindestens k.
Beweis. Wir nehmen an, dass es k + 1 verschiedene Seiten gibt. Wir konstruieren eine
Sequenz von Anfragen σ der Länge n für die gilt, ALG(σ) ≥ k · OPT(σ). Wir benutzen
nun wieder den grausamen Gegenspieler, wie bei der unteren Schranke f ür das ListAccessing-Problem. Die ersten k Anfragen gehen auf verschiedene Seiten. Danach
fordert der grausame Gegenspieler immer genau die Seite an, die nicht im schnellen
25
Speicher von ALG ist. Bei einer Sequenz σ der Länge n hat ALG somit genau n Seitenfehler.
Für den optimalen Offline-Algorithmus LFD hingegen gilt LFD(σ) ≤ n/k. Dieses
sieht man wie folgt: Wir nehmen an, dass LFD bei einer Anfrage die Seite p verdrängt.
Entsprechend der Definition von LFD und weil es nur k + 1 verschiedene Seiten gibt,
müssen alle k Seiten im schnellen Speicher angefragt werden, bevor p wieder angefragt
wird. Also macht LFD höchstens einen Seitenfehler alle k Anfragen.
Damit gilt
n
ALG(σ) = n = k · ≥ k · OPT(σ) .
k
4.2.4 Unterschiedliche Speichergrößen
Um den Nachteil des Online-Algorithmus auszugleichen, erlaube wir, dass der OnlineAlgorithmus mehr Ressourcen benutzen darf als der Offline-Algorithmus. Beim Paging bedeutet das, dass der Online-Algorithmus einen schnellen Speicher der Gr öße
k besitzt, während der Offline-Algorithmus mit einem schnellem Speicher der Gr öße
h ≤ k auskommen muss. Wir haben das Modell also erweitert, denn das bisherige Modell ergibt sich aus dem Fall h = k.
Wir werden nun unsere Ergebnisse bezüglich Marking-Algorithmen auf dieses
Modell erweitern. Mit dem folgenden Theorem kann man folgern, dass ein MarkingAlgorithmus mit doppelt so viel Speicher wie ein optimaler Offline-Algorithmus 2kompetitive ist.
Theorem 4.9 Sei ALG ein Marking-Algorithmus mit Cachegröße k und OPT ein optik
maler Offline-Algorithmus mit Cachegröße h ≤ k. Dann ist ALG k−h+1
-kompetitive.
Beweis. Der Beweis ist eine einfache Erweiterung des Beweises von Theorem 4.5.
Sei σ eine Anfragesequenz. Wir betrachten wieder die Partitionierung von σ in kPhasen. Aus dem Beweis von Theorem 4.5 wissen wir bereits, dass ALG h öchstens k
Seitenfehler pro Phase macht.
Nun zeigen wir, dass OPT pro Phase (bis auf die letzte Phase) mindestens k − h + 1
Seitenfehler macht. Sei q die erste Anfrage in Phase i. Wir betrachten die Sequenz, die
mit der zweiten Anfrage von Phase i beginnt und bis einschließlich zur ersten Anfrage
der Phase i + 1 reicht. Zu Anfang dieser Sequenz hat OPT die Seite q und h − 1 andere
Seiten im schnellen Speicher. In dieser Sequenz gibt es Zugriffe auf k verschiedenen
Seiten, die alle ungleich q sind. Also hat OPT mindestens k − (h − 1) = k − h + 1
Seitenfehler pro Phase (bis auf die letzte Phase).
Also folgt
µ
¶
OPT(σ)
k
ALG(σ) ≤ k ·
+1 =
· OPT(σ) + k .
k−h+1
k−h+1
26
4.3
Randomisierte Algorithmen
Wie sieht die Kompetitiv-Ratio eines randomisierten Algorithmus aus? Wir werden
hier den so genannten blinden Gegenspieler kennenlernen. Sei ALG ein randomisierter Online-Algorithmus. Der blinde Gegenspieler wählt in Kenntnis des Algorithmus
(und seiner Wahrscheinlichkeitsverteilung) eine Eingabesequenz σ aus. Er sieht jedoch
nicht den Ausgang der Zufallsexperimente (daher blinder Gegenspieler). Wir sagen,
dass ALG c-kompetitive ist, wenn für jede Eingabesequenz σ gilt
E [ALG(σ)] ≤ c · OPT(σ) + α ,
wobei α eine Konstante ist, die nicht von σ abhängt. Genau wie im deterministischen
Fall bezeichnet die Kompetitiv-Ratio eines randomisierten Online-Algorithmus ALG
das Infimum über alle Werte c mit der Eigenschaft, dass ALG c-kompetitiv ist.
4.3.1 Randomisierter Marking-Algorithmus
Der randomisierte Marking-Algorithmus Mark assoziieren mit jeder Seite im schnellen Speicher ein Bit, das angibt, ob die jeweilige Seite markiert oder unmarkiert ist.
Zu Beginn einer k-Phase werden alle Markierungen gelöscht. Während einer k-Phase
wird eine Seite markiert, wenn auf sie zugegriffen wird. Bei einem Seitenfehler verdrängt Mark eine uniform zufällig ausgewählte unmarkierte Seite aus dem schnellen
Speicher. Mark ist nun dadurch gekennzeichnet, dass er niemals markierte Seiten aus
dem schnellen Speicher verdrängt.
Wir wollen nun zeigen, dass Mark 2Hk -kompetitive ist, dabei bezeichnet Hk die
k-te harmonische Zahl, d.h. es ist
k
1
.
i=1 i
Hk = ∑
Für die k-te harmonische Zahl gilt
ln k ≤ Hk ≤ ln k + 1 .
Theorem 4.10 Mark ist 2Hk -kompetitive.
Beweis. Sei σ eine Anfragesequenz. Wir betrachten die Partitionierung von σ in kPhasen. Eine Seite, die direkt zu Beginn einer Phase im schnellen Speicher vorhanden
ist, wird als alt bezeichnet. Jede nicht alte Seite, die in einer Phase angefragt wird,
wird als neu bezeichnet. Beachte, dass wiederholte Anfragen auf alte oder neue Seiten
die Kosten von Mark nicht erhöhen, da jede Seite, die während einer Phase angefragt
wird, bis zum Ende der Phase im schnellen Speicher gehalten wird.
Sei mi die Anzahl neuer Seiten, die in Phase i angefragt werden. Innerhalb einer Phase ist es offensichtlich am schlechtesten für Mark, wenn zunächst alle neuen
27
Seiten angefragt werden. Die ersten mi Anfragen nach neuen Seiten verursachen mi
Seitenfehler. Wir untersuchen nun die erwartete Anzahl von Seitenfehlern bez üglich
der k − mi Anfragen nach alten Seiten.
Wir betrachten die erste Anfrage nach der j-ten alten Seite p in Phase i. Zu diesem
Zeitpunkt sind noch k − mi − ( j − 1) unmarkierte alte Seiten im schnellen Speicher und
es gibt insgesamt noch k − ( j − 1) unmarkierte alte Seiten (von denen einige im langsamen Speicher sind). Bei einem Seitenfehler verdrängt Mark eine uniform zufällig
ausgewählte unmarkierte Seite aus dem schnellen Speicher. Daher gilt, dass zum Zeitpunkt dieser Anfrage jede unmarkierte alte Seite mit derselben Wahrscheinlichkeit im
schnellen Speicher vorhanden ist. Also gilt
Pr [p ist im schnellen Speicher] =
k − mi − ( j − 1)
.
k − ( j − 1)
Dann folgt
Pr [p ist nicht im schnellen Speicher] = 1 −
k − mi − ( j − 1)
mi
=
.
k − ( j − 1)
k− j+1
Damit gilt für die erwartete Anzahl von Seitenfehlern in Phase i
mi +
k−mi
∑
j=1
mi
= mi + mi · (Hk − Hmi )
k− j+1
= mi · (Hk − Hmi + 1)
≤ mi · Hk .
Wir müssen nun noch eine untere Schranke für die Kosten eines optimalen OfflineAlgorithmus OPT finden. In den Phase i − 1 und i zusammen werden mindestens k +
mi verschiedene Seiten angefragt, d.h. OPT macht mindestens mi Seitenfehler. In der
ersten Phase macht OPT mindestens m1 Seitenfehler. Dann können wir ∑i gerade mi und
∑i ungerade mi als untere Schranke für die Kosten von OPT benutzen. Eine der beiden
Summen ist mindestens 12 ∑i mi . Also sind die Kosten von OPT mindestens 21 ∑i mi . Da
die erwarteten Kosten von Mark höchstens Hk ∑i mi sind, folgt der Satz sofort.
4.3.2 Randomisierte untere Schranke
Die folgende untere Schranke zeigt, dass Mark asymptotisch optimal ist.
Theorem 4.11 Jeder randomisierte Paging-Algorithmus ALG hat eine KompetitiveRatio von mindestens Hk .
Beweis. Wir nehmen an, dass es k + 1 verschiedene Seiten gibt. Wir konstruieren eine
Anfragesequenz σ. Für jede Anfrage kann der blinde Gegenspieler die Wahrscheinlichkeit p j ausrechnen, dass die Seite j gerade nicht im schnellen Speicher von ALG
vorhanden ist.
28
Die Anfragesequenz σ besteht aus einer beliebig hohen Anzahl von k-Phasen.
Der Gegenspieler benutzt zur Konstruktion einer solchen Phase einen MarkingAlgorithmus. Im folgenden zeigen wir, wie eine Phase konstruiert wird, und wir
zeigen, dass die erwarteten Kosten von ALG für so eine Phase mindestens Hk betragen. Da ein optimaler Offline-Algorithmus so eine Phase mit Kosten eins abarbeiten
kann, folgt damit dann das Theorem.
Eine Phase besteht aus k Subphasen. Zu Beginn der i-ten Subphase sind genau
k − i + 1 unmarkierte Seiten im schnellen Speicher. Am Ende der k-ten Subphase sind
dann alle Seiten markiert und eine neue Phase beginnt. Wir konstruieren die Subphasen
1
so, dass die erwarteten Kosten von ALG für die i-te Subphase k−i+1
betragen. Damit
betragen die erwarteten Kosten von ALG für eine Phase
k
1
∑ k − i + 1 = Hk
.
i=1
Jede Subphase besteht aus null oder mehreren Anfragen nach markierten Seiten
gefolgt von einer Anfrage nach einer unmarkierten Seite. Wir zeigen nun, wie eine
Subphase konstruiert wird. Sei M die Menge der markierten Seiten zu Beginn der iten Subphase. Offensichtlich gilt |M| = i und die Anzahl der unmarkierten Seiten ist
k + 1 − i. Sei γ = ∑ j∈M p j .
• Falls γ = 0, dann gibt es mindestens eine unmarkierte Seite a mit p a ≥ 1/(k +
1 − i). In diesem Fall fragt der Gegenspieler Seite a an und die Subphase endet.
• Falls γ > 0, dann gibt es eine Seite m ∈ M mit pm > 0. Sei ε = pm . Als erstes wird
nun in dieser Unterphase die Seite m angefragt. Solange die erwarteten Kosten
von ALG noch nicht 1/(k + 1 − i) betragen und solange γ > ε ist, frage die Seite
aus M an, die mit der größten Wahrscheinlichkeit nicht im schnellen Speicher
von ALG ist.
Wir stellen zunächst fest, dass die obige Schleife terminiert, da γ > ε ist, und
somit jede Iteration mit γ/M > ε/M zu den erwarteten Kosten von ALG beiträgt.
Wenn die Schleife terminiert, betragen entweder die erwartete Kosten von ALG
mindestens 1/(k + 1 − j) oder es gilt γ ≤ ε. Im letzteren Fall fragt der Gegenspieler die unmarkierte Seite b an, die mit der größten Wahrscheinlichkeit nicht im
schnellen Speicher von ALG ist. Offensichtlich gilt pb ≥ (1 − γ)/(k + 1 − i) und
es folgt somit für die erwarteten Kosten von ALG
ε + pb ≥ ε +
1−γ
1−ε
1
≥ ε+
≥
.
k+1−i
k+1−i k+1−i
29
Kapitel 5
Datenmanagement in Netzwerken
Der Kommunikationsoverhead für die Bereitstellung von Datenobjekten, die von mehreren Knoten in einem Netzwerk bearbeitet werden können, dominiert häufig die Laufzeit von Netzwerkanwendungen. Bei solchen Datenobjekten kann es sich zum Beispiel
um Dateien in einem Local-Area-Network (LAN), globale Variablen auf einem Parallelrechner oder auch virtuelle Seiten in einem verteilten Speichersystem handeln.
In der Standardimplementierung solcher Systeme haben Datenobjekte häufig ein
so genanntes Home, also einen Rechner bzw. Prozessor, der der Ansprechpartner f ür
dieses Objekt ist. In einer naiven Realisierung dieses Konzeptes wird jeder Zugriff
auf ein Datum an sein Home geschickt, das dann bei einem Schreibzugriff das Objekt
entsprechend modifiziert und bei einem Lesezugriff das gesamte Objekt bzw. einen
angefragten Ausschnitt der Daten zurückliefert.
Unter dem Konzept des Cachings versteht man eine raffiniertere Variante, die es
erlaubt Kopien des Objektes zu erzeugen, die im Netzwerk verteilt werden. Falls ein
Prozessor häufiger auf dasselbe Datenobjekt zugreifen möchte, ist es vielleicht sinnvoll, wenn dieser Prozessor eine lokale Kopie erhält, so dass Anfragen von diesem
Prozessor nicht mehr zum Home gesendet werden müssen. Falls jedoch jetzt ein anderer Prozessor dieses Objekt verändern möchte, muss diese Kopie entweder invalidiert
oder aktualisiert werden. Es stellen sich die Fragen, wann wir Kopien erzeugen und
wann wir sie wieder löschen sollen.
Grundsätzlich scheint es sogar möglich und sinnvoll zu sein, das Home eines Prozessors zu verschieben, oder sogar das Home-Konzept ganz aufzugeben und verschiedene gleichrangige Kopien im Netzwerk wandern zu lassen. In einem derartig dynamischen System, stellt sich natürlich auch die Frage, wie die anfragenden Knoten, die
im Netzwerk verteilten Kopien, lokalisieren können, ohne dazu das gesamte Netzwerk
abzusuchen. Diese und andere Fragestellungen werden wir im Folgenden schrittweise
beantworten.
30
5.1
Definition des File-Allocation-Problems (FAP)
Das Netzwerk wird durch einen ungerichteten Graphen G = (V, E) mit nicht-negativen
Kantenlängen aus R beschrieben. Wir betrachten nur ein Datenobjekt x auf das von
allen Prozessoren im Netzwerk lesend und schreibend zugegriffen werden kann. Es
dürfen beliebig viele Kopien von x erzeugt werden. Die Teilmenge der Knoten, die zu
einem Zeitpunkt t ≥ 0 eine Kopie von x besitzen wird als Residenzmenge Rt ⊆ V, Rt 6= 0/
bezeichnet. Zum Zeitpunkt 0 gilt R0 = {v} für einen beliebigen Knoten v ∈ V . Wir
vernachlässigen zunächst das Problem, wie die Kopien im Netzwerk lokalisiert werden
können und setzen globales Wissen über die Residenzmenge voraus, d.h. zu jedem
Zeitpunkt t kennt jeder Knoten die Menge Rt .
Auf dem Netzwerk muss eine Sequenz von Lese- und Schreibanfragen σ =
σ1 · · · σT , mit σt ∈ {r(v), w(v)|v ∈ V }, abgearbeitet werden. Dabei steht σt = r(v)
für eine Leseanfrage von Prozessor v und σt = w(v) für eine Schreibanfrage von v.
Dabei müssen die folgenden Spielregeln eingehalten werden. Nachdem σt präsentiert
ist, führt der Algorithmus die Anfrage durch. Wir kümmern uns nicht um die Details der Durchführung, sondern definieren stattdessen abstrakte Servicekosten f ür die
einzelnen Zugriffe.
• Falls σt = r(v) ist, dann entsprechen die Servicekosten der Distanz von v zum
nächsten Knoten in Rt−1 .
• Falls σt = w(v) ist, dann entsprechen die Servicekosten den Kosten des minimalen Steinerbaumes, der v und Rt−1 aufspannt, also der minimalen Summe der
Kantenlängen, die benötigt wird, um v durch einen Baum mit allen Knoten in
Rt−1 zu verbinden.
Nachdem die Anfrage σt bedient wurde, kann die Residenzmenge angepasst werden,
also Rt−1 in Rt überführt werden. Dazu dürfen neue Kopien erzeugt oder auch vorhandene Kopien verschoben und gelöscht werden. Es muss jedoch immer mindestens eine
Kopie im Netzwerk erhalten bleiben. Das Erzeugen neuer Kopien sowie das L öschen
verursacht keine Kosten. Jedoch dürfen neue Kopien nur auf solchen Knoten erzeugt
werden, die schon eine Kopie haben. Die neue Kopie kann dann entlang der Kanten
verschoben werden. Das Verschieben einer Kopie entlang einer Kante der Länge `
verursacht dabei Migrationskosten in Höhe von `.
5.2
FAP auf Bäumen
Sei der betrachtete Graph ein Baum T = (V, E). Wir präsentieren einen einfachen 3kompetitiven Online-Algorithmus. Dieser Algorithmus hat die folgende Invariante. Zu
jedem Zeitpunkt t ≥ 0 ist der durch die Residenzmenge induzierte Teilgraph zusammenhängend. Für v ∈ V und t ≥ 0 bezeichne Pt (v) die Knoten auf dem kürzesten Weg,
der vom Knoten v zur Residenzmenge Rt führt, inklusive des Quell- und Zielknotens
31
dieses Weges. Nach der Durchführung der Anfrage σt verändert der Algorithmus die
Residenzmenge wie folgt.
• Falls σt = r(v) ist, dann Rt := Rt−1 ∪ Pt−1 (v).
• Falls σt = w(v) ist, dann Rt := Pt−1 (v).
Im Falle einer Leseanfrage durch v erzeugt der Online-Algorithmus also neue Kopien
auf dem Weg Pt−1 (v), und im Falle einer Schreibanfrage von v löscht er die Kopien in
Rt−1 und erzeugt neue Kopien auf Pt−1 (v). Beachte, falls v ∈ Rt−1 ist, so gibt es nach
einer Schreibanfrage von v nur noch eine Kopie, nämlich die Kopie auf dem Knoten v.
Theorem 5.1 Der Online-Algorithmus für FAP auf Bäumen ist 3-kompetitive.
Beweis. Betrachte eine beliebige Kante e = (a, b). O.B.d.A. hat die Kante die Länge
1. Die Entfernung von e aus T würde den Graphen in zwei Teilbäume Ta und Tb zerlegen, die jeweils die Knoten a bzw. b enthalten. Wir unterscheiden drei verschiedene
Konfigurationen.
[A] Nur Ta enthält Kopien von x.
[B] Nur Tb enthält Kopien von x.
[AB] Beide Teilbäume enthalten Kopien.
Beachte, dass in der Konfiguration [AB] garantiert ist, dass beide Knoten a und b
jeweils eine Kopie haben müssen, weil ansonsten die Residenzmenge nicht zusammenhängend wäre. Sei ct ∈ {[A], [B], [AB]} die Konfiguration zum Zeitpunkt t. Der
Schritt von ct−1 nach ct wird als Konfigurationsübergang bezeichnet. Die folgende
Behauptung kann beobachtet werden.
Behauptung 5.2 Der Online-Algorithmus geht niemals in einem Schritt von der Konfiguration [A] direkt in die Konfiguration [B] über und umgekehrt. Es gibt nur die
Übergänge [A] → [AB], [B] → [AB], [AB] → [A] und [AB] → [B].
Damit können wir die Konfigurationssequenz in disjunkte Phasen der Form
[A]+ [AB]+ bzw. [B]+ [AB]+ einteilen. Wir betrachten nun eine derartige Phase und
vergleichen die Kosten des Online-Algorithmus mit den Kosten eines beliebigen
Offline-Algorithmus.
• Zunächst zeigen wir, dass der Online-Algorithmus auf Kante e pro Phase Kosten
drei hat. O.B.d.A. betrachte eine Phase der Form [A]+ [AB]+ . Die Beschreibung
der in solch einer Phase entstehenden Online-Kosten in der Tabelle 5.1 bestätigt
unsere Behauptung.
• Als nächstes zeigen wir, dass jeder Offline-Algorithmus mindestens Kosten eins
pro Phase hat. Zum Zwecke des Widerspruchs nehmen wir an, es gibt eine Strategie mit Kosten null. Dann erfordert die Schreibanfrage (*) aus Ta , dass zu diesem
32
vorherige Konf.
[AB]
[A]
[A]
[AB]
Konf.
[A]
[A]
[AB]
[AB]
Art des Zugriffs
Online-Kosten
Schreibanfrage aus Ta (*)
1
Lese-/Schreibanfrage aus Ta
0
Lese-/Schreibanfrage aus Tb (**)
2
Leseanfrage aus Ta oder Tb
0
Abbildung 5.1: Online-Kosten auf einer Kante in einer Phase der Form [A] + [AB]+ .
Zeitpunkt keine Kopie in Tb enthalten ist, sonst wären die Kosten mindestens eins.
Außerdem kann keine Kopie migriert werden. Also ist auch zum Zeitpunkt der
Lese-/Schreibanfrage (**) aus Tb keine Kopie in Tb enthalten. Damit verursacht
dieser Zugriff jedoch mindestens Kosten eins.
Also hat jeder Offline-Algorithmus mindestens Kosten eins pro Phase, während
der Online-Algorithmus nur Kosten drei hat. Somit ist der Online-Algorithmus 3kompetitive.
Verteilte Ausführung. Bisher sind wir von globalem Wissen ausgegangen. Wir haben angenommen, dass alle Knoten die Konfiguration des Netzwerks kennen. Jetzt
beziehen wir eine verteilte Ausführung in unser Modell mit ein. Wir gehen davon aus,
dass die einzelnen Knoten im Netzwerk nur diejenigen Zugriffe sehen, in die sie involviert sind. Genauer gesagt, ein Knoten sieht einen Lesezugriff nur dann, wenn er auf
dem gewählten Weg zur Zusammenhangskomponente liegt. Analog wird ein Schreibzugriff nur von denjenigen Knoten wahrgenommen, die im f ür die Aktualisierung oder
Invalidierung der Kopien verwendeten Baum enthalten sind. Auch Migrationen werden nur von Knoten, die auf dem Migrationspfad liegen, beobachtet. Um Informationen über eine Veränderung der Residenzmenge auch an andere Knoten im Netzwerk zu
geben, müssen Informationsnachrichten versendet werden. Im folgenden zeigen wir,
dass Informationsnachrichten für die verteilte Ausführung nicht benötigt werden.
Theorem 5.3 Es gibt einen verteilten 3-kompetitiven Online-Algorithmus f ür FAP auf
Bäumen.
Beweis. Wir verwenden eine verteilte Variante des Online-Algorithmuns f ür FAP auf
Bäumen. Wir werden zeigen, wie das so genannte Data-Tracking, d.h. die Lokalisierung der Residenzmenge, auch ohne globales Wissen realisiert werden kann.
Wir erklären einen beliebigen Knoten zur Wurzel des Baumes, z.B. den Knoten
der die initiale Kopie des Datenobjektes hält. Der Algorithmus hält die folgende Invariante aufrecht. Zu jedem diskreten Zeitpunkt gibt es eine Kette von Zeigern auf
dem Weg von der Wurzel zur Residenzmenge, d.h. jeder Knoten auf dem Weg von der
Wurzel zur Residenzmenge kennt seinen Nachfolger auf diesem Weg. Somit kann jede
Lese-/Schreibanfrage auf dem kürzesten Weg zur Residenzmenge gelangen, indem die
entsprechende Nachricht zunächst in Richtung Wurzel des Baumes läuft und dann den
33
Zeigern zur Residenzmenge folgt. Beachte, dass diese Zeiger im Falle einer Migration
ohne weitere Kommunikation aktualisiert werden können, da die betroffenen Knoten
auf dem Migrationspfad liegen und somit die Migration beobachten k önnen.
Für Schreibzugriffe muss nicht nur ein sondern alle Knoten der Residenzmenge lokalisiert werden. Dazu speichern die Knoten in der Residenzmenge jeweils ab, welche
Nachbarn ebenfalls zur Residenzmenge gehören.
5.3
Deterministische untere Schranke für FAP
Die folgende untere Schranke zeigt, dass der obige Online-Algorithmus f ür FAP auf
Bäumen optimal ist, denn selbst auf einer einzelnen Kante kann man keinen besseren
Faktor als drei erreichen.
Theorem 5.4 Betrachte FAP auf einer Kante (a, b) der Länge eins. Jeder deterministische Online-Algorithmus ALG hat eine Kompetitive-Ratio von mindestens drei.
Beweis. Die jeweils zuletzt erzeugte Kopie von ALG bezeichnen wir als neueste Kopie.
Wir betrachten die folgenden drei Offline-Strategien.
• Strategie A hält immer eine Kopie auf a.
• Strategie B hält immer eine Kopie auf b.
• Strategie C hält immer eine Kopie auf demjenigen Knoten, auf dem sich nicht die
neueste Kopie von ALG befindet.
Ein grausamer Gegenspieler konstruiert wie beim Paging die Anfragesequenz σ.
• Wenn ALG auf einem Knoten x ∈ {a, b} keine Kopie hat, dann folgt als nächstes
eine Leseanfrage r(x).
• Wenn ALG auf beiden Knoten a und b Kopien hat, dann folgt als nächstes eine
Schreibanfrage w(x), wobei x derjenige Knoten ist, auf dem sich nicht die neuste
Kopie von ALG befindet.
Die Offline-Strategien A und B haben keine Migrationskosten. Die Migrationskosten der Offline-Strategie C entsprechen genau den Migrationskosten von ALG. Also
haben die drei Offline-Strategien zusammen dieselben Migrationskosten wie ALG. Bei
den Servicekosten ist die Situation ähnlich. ALG hat in jedem Schritt Servicekosten
eins. Dasselbe gilt für die drei Offline-Strategien zusammen. Also gilt
ALG(σ) = A(σ) + B(σ) + C(σ) ≥ 3 · OPT(σ) .
34
5.4
FAP auf allgemeinen Graphen
Auf allgemeinen Graphen ist ein dynamisches Datenmanagement wesentlich komplexer als auf Baumnetzwerken, da die Wege zwischen Knoten nicht mehr eindeutig sind,
und somit auch die Wahl der Routingwege in das Problem einbezogen werden muss.
Dieser Aspekt erschwert das Datenmanagement in fast jeder Hinsicht, angefangen bei
der Platzierung der Kopien bis hin zum Data-Tracking. Wir l ösen dieses Problem indem wir die zuvor beschriebenen Baumalgorithmen auf anderen Netzwerken simulieren. Dazu werden wir eine Methode vorstellen, allgemeine Metriken durch so genannte
Baummetriken zu approximieren. Diese Methode kann nicht nur auf FAP sondern auch
auf zahlreiche andere Optimierungsprobleme angewendet werden. Die Voraussetzung
ist, dass sich die Gesamtkosten einer Lösung als Linearkombination der Kosten einzelner Kanten beschreiben lässt.
5.4.1 Deterministische Approximation von Metriken
Wie auch bei vielen anderen Problemen, basiert das Kostenmodell f ür FAP auf den
Distanzen zwischen Knoten in einem Graphen G = (V, E) mit nicht-negativen Kantenlängen. Die konkrete Graphtopologie ist dabei unwesentlich. Um die Kosten zu
ermitteln, wird eigentlich nur die durch G erzeugte Metrik M ben ötigt. Für jedes Knotenpaar u, v ∈ V beschreibt M die Distanz dM (u, v) zwischen u und v. Allgemein erfüllt
eine Metrik M über einer Knotenmenge V die folgenden Bedingungen:
• Für alle u, v ∈ V gilt: dM (u, v) ≥ 0 (Nicht-Negativität)
• Für alle u, v ∈ V gilt: dM (u, v) = dM (v, u) (Symmetrie)
• Für alle u, v, w ∈ V gilt: dM (u, w) ≤ dM (u, v) + dM (v, w) (Dreiecksungleichung)
Im Folgenden definieren wir, was es bedeutet, eine Metrik durch eine andere Metrik zu approximieren. Eine Metrik N über V dominiert eine Metrik M über V , falls
für jedes u, v ∈ V gilt dN (u, v) ≥ dM (u, v). Eine Metrik N über V α-approximiert eine
Metrik M über V , falls sie M dominiert und für alle u, v ∈ V gilt dN (u, v) ≤ αdM (u, v).
Eine Metrik N über V ist eine Baummetrik, falls es einen Baum T = (V, E) gibt,
der die Metrik N erzeugt. Wir möchten allgemeine Metriken durch Baummetriken
approximieren. Die folgende untere Schranke zeigt, dass dies deterministisch nicht
sinnvoll funktionieren kann.
Theorem 5.5 Für jedes n ∈ N gibt es eine Metrik M über n Knoten, so dass für jede
Baummetrik N über n Knoten gilt, falls M durch N α-approximiert wird, gilt α = Ω(n).
Beweis. Sei G = (V, E) der Kreis über n Knoten. Insbesondere sei V = {0, . . . , n − 1}
und E = {(i, j)|i = j + 1 mod n}. Alle Kanten in G haben Länge 1. G erzeuge die
Metrik M. T = (V, ET ) bezeichne den Baum, der N erzeugt. Zur Vereinfachung der
35
Notation nehmen wir an, dass n gerade ist, und dass α < n4 eine ganze Zahl ist. Zum
Zwecke des Widerspruchs nehmen wir an, dass N eine α-Approximation von M ist.
Zuerst zeigen wir, dass jede Kante in ET höchstens Länge α hat. Zum Zwecke des
Widerspruchs nehmen wir an, dass es eine Kante e = (a, b) ∈ ET mit Länge größer als
α gibt. Dann gibt es zwei Teilbäume Ta und Tb , so dass für jedes Knotenpaar (u, v) mit
u aus Ta und v aus Tb gilt dN (u, v) > α. Da N die Metrik M α-approximiert, können
Nachbarn im Kreis aber höchstens Abstand α im Baum haben. Also sind entweder alle
Knoten aus V im Teilbaum Ta oder alle im Teilbaum Tb enthalten. Ein Widerspruch.
Jetzt definieren wir zwei Knotenmengen A = {0, . . . α − 1} und B = { 2n , . . . n2 +
α − 1}. Nun färben wir die Knoten in V \ (A ∪ B) mit zwei Farben. Die Knoten in
{α, . . . 2n − 1} werden blau gefärbt und die Knoten in { 2n + α, . . . n − 1} werden rot
gefärbt. Beachte, zwischen je einem blauen und einem roten Knoten ist die Distanz im
Kreis größer als α. Somit folgt, dass es keine Kante (u, v) ∈ ET zwischen einem blauen
Knoten u und einem roten Knoten v geben kann, weil sonst d M (u, v) > α ≥ dN (u, v)
gelten würde, was im Widerspruch zur Dominanz von N über M stünde. Wir fassen
zusammen: Zwischen roten und blauen Knoten gibt es keine Kante in E T .
Sei a ∈ A und b ∈ B. Im Kreis haben a und b die Distanz 2n − α ≥ n4 . Aufgrund der
Dominanz von N über M folgt, dass die Entfernung im Baum nicht geringer sein darf.
Sei a 6= a0 ∈ A. b kann nicht auf dem Pfad liegen, der a und a0 in T verbindet, den sonst
gäbe es zwei Knoten in A, die im Kreis benachbart sind, aber im Baum mindestens
Distanz n4 hätten. Die α-Approximation erlaubt jedoch höchstens eine Distanz von α <
n
4 für im Kreis benachbarte Knoten. Mit dieser Eigenschaft k önnen wir nun die Wälder
TA und TB definieren: TA bzw. TB enthält die vollständigen Teilbäume, die jeweils eine
Wurzel aus A bzw. B haben, aber die keinen Knoten aus B bzw. A enthalten.
Wenn wir TA und TB aus T entfernen würden, so bleibt ein zusammenhängender
Restbaum R über. Per Definition besteht R nur aus gefärbten Knoten. Tatsächlich besteht R entweder nur aus blauen oder nur aus roten Knoten, denn sonst w ürde es in R
ein benachbartes Paar Knoten mit unterschiedlichen Farben geben. O.B.d.A. k önnen
wir also annehmen das R nur aus roten Knoten besteht.
Die blauen Knoten sind entweder alle in TA oder in TB enthalten, denn sonst gäbe
es zwei blaue im Kreis benachbarte Knoten, die im Baum mindestens Distanz 4n hätten.
Die α-Approximation erlaubt jedoch höchstens eine Distanz von α < n4 für im Kreis
benachbarte Knoten. O.B.d.A. können wir also annehmen alle blauen Knoten sind in
TA enthalten.
Jetzt betrachte das Knotenpaar u = 2n − 1 und v = n2 . Im Baum finden wir u in TA ,
da er zu den blauen Knoten gehört, und v in TB , da er zur Menge B gehört. Es folgt
dN (u, v) ≥ 4n > α. Aus der Nachbarschaft auf dem Kreis folgt jedoch dM (u, v) = 1.
Also erhalten wir einen Widerspruch zur α-Approximation von M durch N.
36
5.4.2 Probabilistische Approximation von Metriken
Eine probabilistische α-Approximation einer Metrik M über V durch Baummetriken
ist definiert durch eine Menge von Baummetriken S über V mit einer assoziierten
Wahrscheinlichkeitsverteilung P : S → [0, 1], die die folgenden Bedingungen erf üllt:
• Jede Baummetrik N ∈ S , dominiert die Metrik M.
• Für ein zufällig gemäß P gewähltes N ∈ S gilt: E [dN (u, v)] ≤ α · dM (u, v) für alle
u, v ∈ V .
Bartal hat gezeigt, dass es für jede Metrik M über eine Knotenmenge V eine probabilistische O(log |V | log log |V |)-Approximation durch Baummetriken gibt. Das folgende leicht verbesserte Ergebnis geht zurück auf Fakcharoenphol, Rao und Talwar.
Theorem 5.6 Für jede Metrik M über eine Knotenmenge V gibt es eine probabilistische O(log |V |)-Approximation durch Baummetriken.
Dieses Ergebnis ist optimal, denn es gibt eine Metrik M für die es nachweisbar keine probabilistische o(log |V |)-Approximation durch Baummetriken gibt. Wir werden
diesen Satz nicht in seiner Allgemeinheit beweisen, sondern uns die grundlegende Beweisidee anhand eines relativ einfachen Beispiels klarmachen. Als Beispiel betrachten
wir die Metrik M, die durch den zwei-dimensionalen (n × n)-Torus G = (V, E), mit
V = {0, . . . n − 1}2 ,
E = {{(x, y), ((x + 1) mod n, y)}, {(x, y), (x, (y + 1) mod n)}|(x, y) ∈ V }
und uniformen Kantenlängen, erzeugt wird.
Theorem 5.7 Sei n = 2d . Für die (n × n)-Torusmetrik M über V = {0, . . . n − 1}2 gibt
es eine probabilistische 8d-Approximation durch Baummetriken.
Beweis. Durch eine hierarchische Partitionierung des Torus definieren wir zunächst
einen Dekompositionsbaum. Dazu teilen wir den Torus in vier disjunkte ( 2n × n2 )Teilgitter, die wiederum rekursiv in vier disjunkte, quadratische Teilgitter aufgeteilt
werden, bis wir einzelne Knoten erreichen. Mit dieser Partitionierung ist ein 4-ärer
Dekompositionsbaum der Tiefe d verbunden, in dem die Wurzel den gesamten Torus
und jeder Knoten auf Ebene i ∈ {1, . . . d} dieses Baumes jeweils ein Teilgitter mit
Seitenlänge n/2i repräsentiert.
In jedem dieser Teilnetzwerke wählen wir jetzt iterativ einen Leiter. Wir beginnen
mit den Teilgittern auf Ebene d des Dekompositionsbaumes. Als Leiter solch eines
Teilgitters, das nur aus einem Knoten besteht, wählen wir diesen einen Knoten. Nachdem wir die Leiter auf Ebene i ∈ {1, . . . d} bestimmt haben, widmen wir uns der Ebene
i − 1. Als Leiter eines Teilgitters S auf Ebene i − 1 wählen wir einen beliebigen Knoten
aus der Menge der Leiter der Teilgitter auf Ebene i, in die S partitioniert wird. Die
Distanz dieses Leiters zu einem beliebigen Knoten in S ist durch 2n/2 i−1 beschränkt.
37
Wir beschriften nun die Knoten des Dekompositionsbaumes. Jeder Baumknoten
erhält das Label des Leiters im jeweiligen Teilgitter. Beachte, dass einzelne Label
im Baum mehrfach vorkommen können, während sie im Torus eindeutig sind. Als
nächstes weisen wir den Baumkanten Distanzwerte zu. Eine Kante zwischen zwei
Baumknoten mit Label u und v erhält die Distanz der gleichnamigen Knoten im Torusnetzwerk. Kanten, deren inzidente Knoten dasselbe Label tragen, erhalten dabei den
Distanzwert 0.
Wenn wir nun Baumknoten mit gleichem Label miteinander identifizieren, so erhalten wir eine Baummetrik N über V = {0, . . . n − 1}2 , die die Torusmetrik M dominiert, weil für jede Kante im Baum ein Weg gleicher Länge im Torus existiert, so dass
gilt dM (u, v) ≤ dN (u, v) für alle u, v ∈ V . Beachte, dass diese Aussage gilt, weil wir die
Leiter so gewählt haben, dass der Graph, der jeweils durch Baumknoten mit gleichem
Label induziert wird, zusammenhängend ist.
Die oben beschriebene Dekomposition ist nicht eindeutig, da wir die Koordinaten
der Partionierung auf der obersten Rekursionsebene nicht festgelegt haben. Tatsächlich
gibt es n2 Möglichkeiten für die Partitionierung auf der obersten Rekursionsebene. Sobald dieser erste Partionierungsschritt jedoch festgelegt ist, sind auch die nachrangigen
Partionierungen eindeutig bestimmt. Tatsächlich erhalten wir also eine Familie von n2
Dekompositionsbäumen mit verschiedenen Beschriftungen von denen jeder eine unterschiedliche Baummetrik über V erzeugt, die die Torusmetrik M dominiert. Um eine
probabilistische Approximation von M zu erhalten, definieren wir jetzt, dass die Menge
S eben aus diesen n2 verschiedenen Baummetriken besteht. Als Wahrscheinlichkeitsverteilung über S wählen wir die uniforme Verteilung.
Wir müssen nun die erwartete Distanz zwischen zwei beliebigen Knoten aus V
bezüglich einer zufällig aus S gewählten Metrik N abschätzen und beweisen, dass die
erwartete Distanz in N höchsten 8d mal so groß ist wie die Distanz in der Torusmetrik
M. Seien u = (u1 , u2 ) und v = (v1 , v2 ) beliebig gewählte Knoten aus V . Bezeichne δ1
die Distanz zwischen diesen beiden Knoten bezüglich der ersten Koordinate (Zeilen)
im Torus und δ2 die Distanz bezüglich der zweiten Koordinate (Spalten). Um eine obere Schranke für dN (u, v) zu erhalten, ist es jetzt sinnvoll sich den Dekompositionsbaum
wieder als vollständigen 4-ären Baum der Tiefe d vorzustellen. Wir identifizieren u und
v mit den Blättern, die das entsprechende Label tragen.
Die Wahrscheinlichkeit, dass u und v durch die horizontale Partitionierung des Torus auf der obersten Rekursionsebene getrennt werden, ist h öchstens 2δ1 /n, da auf dieser Ebene zwei horizontale Schnitte vorgenommen werden, und jeder dieser Schnitte
eine der δ1 Kantenschichten, die zwischen den Zeilen von u und v liegen, mit Wahrscheinlichkeit δ1 /n durchtrennt. Für die vertikale Partitionierung ist die entsprechende
Wahrscheinlichkeit höchstens 2δ2 /n. Bezogen auf den Dekompositionsbaum schließen wir, dass der kürzeste Weg zwischen u und v die Wurzel mit Wahrscheinlichkeit höchstens 2(δ1 + δ2 )/n enthält. Allgemein gilt, die Wahrscheinlichkeit, dass der
kürzeste Weg zwischen den beiden Knoten u und v einen Knoten von Ebene i des
Dekompositionsbaumes enthält, ist höchstens 2i+1 · (δ1 + δ2 )/n, da 2i+1 horizontale
38
und 2i+1 vertikale Schnitte vorgenommen werden, die zur Aufteilung von u und v in
verschiedene Teilbäume unterhalb der Ebene i führen.
Daraus berechnen wir jetzt welche Baumkanten mit welcher Wahrscheinlichkeit überschritten werden. Wir definieren, dass die Baumkanten auf Schicht i f ür
i ∈ {0, . . . d − 1} zwischen den Knoten der Ebene i und den Knoten der Ebene i + 1
verlaufen.
• Mit Wahrscheinlichkeit höchstens 2i+1 · (δ1 + δ2 )/n führt der kürzeste Weg von
u nach v über Kantenschicht i.
• Von jeder Kantenschicht werden maximal zwei Kanten benutzt.
• Die Kanten aus Schicht i haben Länge höchsten 2n/2i .
Daraus errechnet sich
E [dN (u, v)] =
d−1 i+1
2 · (δ
∑
i=0
1 + δ2 )
n
·2·
2n
= 8d · (δ1 + δ2 ) = 8d · dM (u, v) .
2i
5.4.3 Randomisierter Online-Algorithmus
Aus der obigen Approximation von allgemeinen Metriken durch Baummetriken konstruieren wir einen randomisierten Algorithmus für FAP auf allgemeinen Graphen. Der
randomisierte Online-Algorithmus für FAP auf einem Graphen G = (V, E) arbeitet wie
folgt. Sei M die durch G erzeugte Metrik. In einem Preprocessing wird die f ür eine αApproximation von M benötigte Menge von Baummetriken S sowie die zugehörige
Wahrscheinlichkeitsverteilung P berechnet. Eine zufällige Baummetrik N wird aus S
gemäß P gewählt und ein Baum T = (V, ET ) wird konstruiert, der diese Metrik erzeugt. Dann wird der in Satz 5.3 beschriebenen 3-kompetitiven Baumalgorithmus A
für T simuliert.
Lemma 5.8 Der obige Algorithmus ist 3α-kompetitive.
Beweis. Fixiere eine Anfragesequenz σ. Für einen Algorithmus B und eine Metrik Q
bezeichne CBQ die Kosten
£ M ¤von B aufMσ unter Q. Wir werden beweisen, dass für jeden
Algorithmus B gilt E CA ≤ 3α · CB . Aus dieser Behauptung folgt unmittelbar, dass
der Algorithmus 3α-kompetitive ist.
Sei B nun ein beliebiger Algorithmus. Die Gesamtkosten beim FAP lassen sich
als eine Linearkombination von Kosten einzelner Kanten interpretieren. Insbesondere
können wir die Kosten von B auf die Knotenpaare umlegen, d.h. wir k önnen jedem
Knotenpaar u, v ∈ V einen absoluten Kostenwert CB (u, v) zuordnen, so dass für jede
39
Metrik Q gilt
CBQ =
∑
u,v∈V
CB (u, v) · dQ (u, v) .
Für Algorithmus B auf der zufällig ausgewählten Metrik N gilt somit
"
#
£ N¤
E CB = E ∑ CB (u, v) · dN (u, v)
u,v∈V
=
∑
CB (u, v) · E [dN (u, v)]
∑
CB (u, v) · αdM (u, v)
u,v∈V
≤
=
u,v∈V
α ·CBM
.
£ ¤
£ ¤
Aufgrund der
von ¤N über M,
ist¤E CAM ≤ E CAN . Weil A 3-kompetitive
£
£ Dominanz
¤
£
für N ist, gilt E CAN ≤ E 3 ·CBN = 3 · E CBN . Insgesamt erhalten wir somit
£ ¤
£ ¤
£ ¤
E CAM ≤ E CAN ≤ 3 · E CBN ≤ 3α ·CBM .
Das obige Lemma zusammen mit Satz 5.6 liefert das folgende Ergebnis.
Korollar 5.9 Für jeden Graphen G = (V, E) gibt es einen verteilten, randomisierten
Online-Algorithmus für FAP der O(log |V |)-kompetitive ist.
40
Kapitel 6
Lastbalancierung
Wir beschäftigen uns in diesem Kapitel mit dem Problem der Lastbalancierung. Bei
diesem Problem werden Aufgaben an Maschinen verteilt, so dass die maximale Auslastung der Maschinen minimiert wird. Wir haben eine Menge von m öglicherweise
verschiedenen Maschinen gegeben und in der Online-Version des Problems erscheinen die Aufgaben nacheinander und müssen sofort einer der Maschinen zugewiesen
werden. Dabei erzeugt jede Aufgabe auf den Maschinen eine Last (die m öglicherweise von der Maschine abhängt). Zu jedem Zeitpunkt hat also jede Maschine i eine Last
li . Das Ziel ist es, die maximale Auslastung, d.h. max{li : 1 ≤ i ≤ N}, zu minimieren.
6.1
Identische Maschinen
Als erstes werden wir uns die einfachste Variante des Lastbalancierungsproblems anschauen. Dabei haben wir N identische Maschinen. Eine Eingabesequenz von Aufgaben soll den einzelnen Maschinen zugewiesen werden. Jede Aufgabe erzeugt eine Last
auf der zugewiesenen Maschine. Da die Maschinen identisch sind, hängt auch die zugewiesene Last nicht von der Maschine ab. Man muss also die Aufgaben nur m öglichst
gleichmäßig auf die Maschinen verteilen.
Wir betrachten folgenden Algorithmus.
• Greedy: Jede eingehende Aufgabe wird der Maschine zugewiesen, die die niedrigste Last hat. Haben zwei Maschinen identische Last, wird die Maschine mit
der kleineren Nummer gewählt.
Theorem 6.1 Für N Maschinen erreicht Greedy eine Kompetitive-Ratio von 2 − N1 .
Beweis. Wir zeigen zunächst, dass Greedy keine bessere Kompetitive-Ratio als 2 − N1
erreicht. Dazu betrachten wir eine Sequenz, die zunächst aus N · (N − 1) Aufgaben
mit Last 1 besteht, gefolgt von einer einzigen Aufgabe mit Last N. Offensichtlich wird
Greedy einer Maschine eine Last von 2N − 1 zuweisen, während ein optimaler OfflineAlgorithmus jeder Maschine genau eine Last von N zuweist. Also sind die Kosten
41
von Greedy auf dieser Sequenz (2 − N1 )-mal so hoch wie die eines optimalen OfflineAlgorithmus.
Wir zeigen nun, dass es keine schlechtere Eingabesequenz gibt. Sei dazu σ eine
beliebige Eingabesequenz. O.b.d.A. nehmen wir an, dass die h öchste Last von Greedy
auf Maschine 1 entsteht. Sei w das Gewicht der letzten Aufgabe, die an Maschine 1
zugewiesen wurde und es sei s das Gewicht von Maschine 1 vor dieser Zuweisung.
Also sind die Kosten von Greedy genau w + s. Außerdem ist nat ürlich die Last auf
jeder anderen Maschine ebenfalls mindestens s, denn sonst wäre der letzte Job nicht
Maschine 1 zugewiesen worden. Also ist die Gesamtlast mindestens w + N · s. Daraus
folgt, dass OPT(σ) ≥ max{ w+Ns
N , w} ist. Es gilt daher
Greedy(σ) = w + s
w + Ns
≤ w + s + OPT(σ) −
N
w
= w + OPT(σ) −
N
1
= OPT(σ) + (1 − ) · w
N
1
≤ OPT(σ) + (1 − ) · OPT(σ)
N
1
= (2 − ) · OPT(σ) .
N
6.2
Eingeschränkte Maschinen
Im Modell für eingeschränkte Maschinen haben wir wieder N identische Maschinen.
Allerdings kann nicht jede Aufgabe jeder Maschine zugewiesen werden. Daher gibt
es zu jeder Aufgabe eine Menge von zugelassenen Maschinen, denen die Aufgabe
zugewiesen werden darf. Wir können nun den Algorithmus Greedy auf dieses neue
Modell erweitern, indem eine Aufgabe der zugelassenen Maschine zugewiesen wird,
die die geringste Last hat.
Theorem 6.2 Für N eingeschränkte Maschinen ist Greedy (dlog Ne + 1)-kompetitive.
Beweis. Sei σ = σ1 · · · σn eine Eingabesequenz, wobei Aufgabe σk eine Last wk auf
n w
i
einer zugelassenen Maschine erzeugt. Offensichtlich gilt OPT(σ) ≥ ∑i=1
N .
Wir betrachten nun die Zuweisung dieser Aufgaben durch Greedy an die einzelnen
Maschinen. Wir teilen diese Zuweisung in Schichten ein. Jede Schicht hat eine Dicke
von OPT(σ). Diese Einteilung kann dazu führen, dass Aufgaben zwischen zwei aneinandergrenzenden Schichten aufgeteilt werden (aufgrund der Gr öße der Schichten,
kann eine Aufgabe nicht auf mehr als zwei aneinandergrenzende Schichten aufgeteilt
42
werden). Wir bezeichnen mit Wi die Gesamtlast, die Greedy in Schicht i den Maschinen zuweist (die Last von Aufgaben, die auf zwei Schichten aufgeteilt wurden, wird
gemäß dieser Aufteilung berücksichtigt). Es gilt also für die Gesamtlast
n
N
i=1
i=1
W = ∑ wk = ∑ Wi .
Wir bezeichnen mit
i
Ri = W − ∑ W j
j=1
die Restlast, die noch nicht in Schicht 1, . . . i vollständig durch Greedy zugewiesen
wurde. Wir zeigen nun, dass sich in jeder Schicht die Restlast halbiert. Zunächst beweisen wir folgendes Lemma.
Lemma 6.3 Ri ≤ Wi .
Beweis. Wir benötigen die folgende Notation.
• Wi j : Die Last auf Maschine j in Schicht i.
• zik : Die (partielle) Last von Aufgabe σk in Schicht i. Für σk gibt es maximal zwei
aufeinanderfolgenden Schichten mit zik > 0.
• Oi j : Die Menge der Aufgaben die OPT Maschine j zuweist und die noch nicht in
Schicht 1, . . . i vollständig durch Greedy zugewiesen wurden.
• Ri j : Die Summe der (partiellen) Lasten von Aufgaben in Oi j .
Wir zeigen, dass Ri j ≤ Wi j ist. Damit ist dann
Ri =
N
∑ Ri j ≤
j=1
N
∑ Wi j = Wi
,
j=1
und das Lemma folgt somit.
Wenn Oi j = 0/ ist, folgt Ri j = 0 ≤ Wi j . Wenn Wi j = OPT(σ) ist, folgt Ri j ≤
OPT(σ) = Wi j .
Daher verbleibt nur der Fall, dass Oi j 6= 0/ und Wi j < OPT(σ) ist. Sei r die Maschine, der Greedy die Aufgabe σk ∈ Oi j zuweist. Aus Wi j < OPT(σ) folgt, dass r 6= j
ist. Es gilt Wir − zik ≤ Wi j , ansonsten hätte Greedy die Aufgabe σk der Maschine j
zugewiesen. Es ist Wir = OPT(σ), ansonsten wäre σk 6∈ Oi j . Zusammenfassend gilt
OPT(σ) − zik ≤ Wi j .
Mit der Beobachtung, dass ∑σk ∈Oi j wk ≤ OPT(σ) ist, können wir dann folgern
Ri j =
∑
σk ∈Oi j
wk − zik ≤ OPT(σ) −
43
∑
σk ∈Oi j
zik ≤ Wi j .
Aus dem Lemma folgt Ri ≤ Wi = Ri−1 − Ri , und somit gilt Ri ≤
Rdlog Ne ≤
Ri−1
2 .
Deshalb ist
R0 W
=
≤ OPT(σ) .
N
N
Damit kann die Restlast Rdlog Ne in Schicht dlog Ne + 1 abgearbeitet werden und der
Satz folgt.
6.3
Verwandte Maschinen
Im Modell der verwandten Maschinen haben wir wieder N Maschinen. Allerdings
hat jede Maschine i eine Geschwindigkeit αi , so dass eine Aufgabe der Größe w auf
Maschine i eine Last von w/αi erzeugt. Zunächst werden wir nun annehmen, dass
OPT(σ) ≤ Λ ist. Unter dieser Annahme betrachten wir den Algorithmus Slowfit Λ .
• SlowfitΛ : Jede eingehende Aufgabe wird der langsamsten Maschine zugewiesen,
die nach der Zuweisung noch eine Last von höchstens 2Λ hat. Wir sagen, dass
SlowfitΛ einen Fehler macht, wenn es keine solche Maschine gibt.
Theorem 6.4 Für eine Eingabesequenz σ, mit OPT(σ) ≤ Λ, macht SlowfitΛ keinen
Fehler uns es gilt SlowfitΛ (σ) ≤ 2Λ.
Beweis. Sei σ = σ1 · · · σn eine Eingabesequenz, wobei Aufgabe σk die Größe wk hat.
Es reicht zu zeigen, dass SlowfitΛ keinen Fehler macht, denn dann gilt offensichtlich
SlowfitΛ (σ) ≤ 2Λ. Dieses wollen wir per Wiederspruch zeigen. Wir nehmen an, dass
OPT(σ) ≤ Λ ist und dass SlowfitΛ bei der n-ten Aufgabe einen Fehler macht.
O.B.d.A. nehmen wir an, dass die Maschinen von der langsamsten zur schnellsten
aufsteigend angeordnet sind, d.h. α1 ≤ · · · ≤ αN . Mit lt (i) bezeichnen wir die Last
der Maschine i nachdem die Aufgabe σt zugewiesen ist. Wir nennen eine Maschine i
ausgelastet, wenn ln−1 (i) > OPT(σ) ist. Wir nennen eine Maschine i überladen, wenn
die Maschinen {i, . . . N} ausgelastet sind. Sei Γ die Menge der überladenen Maschinen.
Lemma 6.5 Sei Si (Si∗ ) die Menge der Aufgaben, die Maschine i durch SlowfitΛ (OPT)
zugewiesen werden. Dann ist
∑
i∈Γ,s∈Si
ws >
∑
ws .
i∈Γ,s∈Si∗
Beweis. Es muss Γ 6= 0/ sein. Ansonsten würde SlowfitΛ die n-te Aufgabe der schnellsten Maschine zuweisen, denn die Last einer Aufgabe auf der schnellsten Maschine ist höchstens OPT(σ), und damit wäre die Last nach dieser Zuweisung höchsten
2 · OPT(σ) ≤ 2Λ und SlowfitΛ würde somit keinen Fehler machen.
44
Für Γ 6= 0/ folgt
∑
i∈Γ,s∈Si
ws
s∈Si αi
∑ αi ∑
ws =
i∈Γ
∑ αi · OPT(σ)
>
i∈Γ
ws
∑ αi ∑∗ αi
≥
i∈Γ
∑
=
s∈Si
ws .
i∈Γ,s∈Si∗
Es gibt mindestens eine Maschine, die nicht überladen ist. Für Γ = {1, 2, . . . , N}
würde gelten
∑ ws = ∑ ws ,
i∈Γ,s∈Si
i∈Γ,s∈Si∗
was im Wiederspruch zu Lemma 6.5 steht. Wir bezeichnen mit f die schnellste Maschine, die nicht überladen ist.
Es gibt eine Aufgabe σs mit s < n, die von SlowfitΛ einer Maschine m ∈ Γ zugewiesen wird und die von OPT einer langsameren Maschine m0 6∈ Γ zugewiesen wird.
Aus der Annahme, dass eine solche Aufgabe nicht existiert, k önnen wir folgern, dass
jede Aufgabe, die von SlowfitΛ einer Maschine i ∈ Γ zugewiesen wird, auch von OPT
einer Maschine i0 ∈ Γ zugewiesen wird. Dann gilt
∑
i∈Γ,s∈Si
ws ≤
∑
ws ,
i∈Γ,s∈Si∗
was im Wiederspruch zu Lemma 6.5 steht.
Also können wir folgern
ws
ws
≤ OPT(σ) ≤ Λ .
≤
αf
α m0
Außerdem gilt
ls−1 ( f ) ≤ ln−1 ( f ) ≤ OPT(σ) ≤ Λ .
Daraus folgt, dass ls−1 ( f ) + αwsf ≤ 2Λ ist. Damit hätte SlowfitΛ die Aufgabe σs aber der
Maschine f (oder eine langsamere Maschine) anstelle der Maschine m ∈ Γ zuweisen
müssen.
Bisher benötigten wir für den Algorithmus SlowfitΛ eine Schranke Λ bezüglich der
maximalen Last eines optimalen Offline-Algorithmus. Wir werden nun aus Slowfit Λ
den Algorithmus Slowfit konstruieren, der keine solche obere Schranke mehr ben ötigt.
Der Algorithmus Slowfit läuft in Phasen ab. In der Phase 0 führen wir den Algorithmus SlowfitΛ0 aus, wobei Λ0 der Größe der ersten Aufgabe entspricht. Wenn der
45
Algorithmus SlowfitΛ0 bei einer Aufgabe einen Fehler macht, dann beginnt mit dieser
Aufgabe die nächste Phase. In der Phase i führen wir den Algorithmus SlowfitΛi aus,
wobei Λi = 2i · Λ0 ist. Wenn der Algorithmus SlowfitΛi bei einer Aufgabe einen Fehler
macht, dann beginnt mit dieser Aufgabe die nächste Phase.
Theorem 6.6 Der Algorithmus Slowfit ist 8-kompetitive.
Beweis. Wir bezeichnen mit σi den Teil der Eingabesequenz, der in Phasen i abgearbeitet wird. Sei h die Phase, in der Slowfit terminiert. Dann gilt mit Satz 6.4
OPT(σ) ≥ OPT(σ0 · · · σh−1 r) > 2h−1 · Λ0 ,
wobei r die Aufgabe bezeichnet, die den Fehler am Ende von Phase h − 1 erzeugt.
Für die maximale Last von Slowfit gilt
h
h
i=0
i=0
Slowfit(σ) = ∑ SlowfitΛi (σi ) ≤ ∑ 2i+1 Λ0 ≤ 2h+2 Λ0 .
Damit ist das Theorem bewiesen.
46