Charging Schema:

Jenseits der reinen kompetitiven
Analyse:
Access Graphen
Inhaltsangabe:
1.
Einleitung
1.1.
1.2.
1.3.
Online /Offline Algorithmus ................................................... 3
Kompetitive Analyse ............................................................... 3
Paging ...................................................................................... 3
2. Access Graphen Modell
2.1.
2.2.
2.3.
2.4.
Modellbeschreibung ................................................................ 4
Zielsetzung .............................................................................. 5
Theoretische Berechenbarkeit ................................................. 5
Einheitlich kompetitver Algorithmen ...................................... 6
3. FiFo im Access Graph
3.1.
3.2.
3.3.
k-Phase .................................................................................... 6
Untere Schranke für Fifo ......................................................... 6
Spezialfall: FiFo auf Knotenlinie ............................................ 8
4. LRU im Access Graph
4.1.
4.2.
4.3.
Obere und untere Schranke für LRU ....................................... 8
Spezialfall: LRU auf Knotenlinie ............................................13
Vergleich: LRU gegen FiFo ................................................... 13
5. FAR im Access Graph
5.1
5.2.
Obere und untere Schranke für Algorithmus FAR ................ 14
Algorithmus FAR: einheitlich kompetitver Algorithmus ...... 16
6. Zusammenfassung und Ausblick
6.1.
6.2.
6.3.
6.4
FiFo, LRU, FAR .................................................................... 19
Dynamischer Access Graph ................................................... 19
Algorithmus FARL ................................................................ 20
Fazit ........................................................................................ 20
1
1. Einleitung
1.1. Online / Offline Algorithmen:
Ein Offline Algorithmus kennt zu beginn alle relevanten Daten und kann diese nutzen.
Im Gegensatz dazu erfolgt bei einem Online Algorithmus die Dateneingabe portionsweise.
Das heißt der Online Algorithmus muss die portionsweisen Eingaben verarbeiten, ohne dass
er die zukünftigen Eingaben (z.B.: Operationen / Anfragen ) kennt.
Dies spiegelt die Probleme aus unserem täglichen Leben wieder.
Z.B.:
1. Die Bewegungsplanung bei unvollständigen Informationen:
Ein Roboter, der sich auf unbekannten Terrain vorwärts bewegt, muss auf ein
Hindernis z.B. einem Ball der durch den Raum rollt reagieren, ohne dass er weiß, dass
er als nächstes einem Menschen ausweichen muss.
2. Die Spekulation mit Aktien:
Ein Aktionär weiß nicht wie sich der weitere Aktienkurs entwickeln wird und kann
nur auf den soeben gefallenen oder gestiegen Aktienkurs mit kaufen oder verkaufen
reagieren.
3. Das Routing im Internet:
Die Suchmaschine kann immer nur die aktuell gestellte Anfrage berücksichtigen,
ohne Kenntnisse darüber was der Benutzer als nächstes eingeben wird.
1.2. Kompetitive Analyse
Eine Möglichkeit Online Algorithmen zu vergleichen ist die reine kompetitive Analyse.
Aus der wir einige Begriffe benötigen, die wie folgt definiert sind:
Definiton: (c-kompetitiv)
Sei ALG ein Online-Algorithmus.
Wir nennen ALG c-kompetitiv, wenn es eine Konstante α gibt, s.d.:
ALG ( I ) ≤ c OPT ( I ) + α
∀ endlichen Eingabesequenzen I
Definition: (Kompetitive Komplexität von ALG)
Sei ALG ein Online-Algorithmus.
Die kompetitive Komplexität von ALG ist das Infimum über alle c,
s.d. ALG noch c-kompetitiv ist.
1.3. Paging (Caching) „Seitenaustausch“
Ein typisches fundamentales und praktisch wichtiges Online Problem in der Informatik ist das
Paging-Problem. Es behandelt das Austauschen von Seiten zwischen schnellem (Kernspeicher
/ Cache) und langsamen Speicher (Hintergrundspeicher / Festplatte ).
Sei z.B. k der Cache, der für k Seiten Platz hat und N der langsame Speicher, der N Seiten
speichern kann, wobei klar ist dass N > k ist.
Die N Seiten im langsamen Speicher repräsentieren den virtuellen Speicher.
2
Ein Paging-Algorithmus muss eine Anfragesequenz an den virtuellen Speicher bedienen.
Unser Kostenmodell hierfür sieht wie folgt aus:
Wird eine Seite x angefragt und ist die angefragt Seite im Cache, dann gibt es einen Treffer („
HIT “) und es entstehen keine Kosten.
Ist die Seite nicht im Cache, gibt es einen Seitenfehler.
Bei einem Seitenfehler (Miss) lädt man die Seite x in den Cache, was Kosten verursacht.
Bei diesem Vorgang muss der Algorithmus entscheiden, welche der k Seiten, die momentan
im Cache sind er in den langsamen Speicher verdrängen will bzw. welche Seite er am
sinnvollsten verdrängt im Bezug auf die zukünftigen Anfragen (die ein Online Algorithmus
aber nicht kennt). Dabei sind verschiedene Strategien möglich:
1. Offline Strategie : (setzt Kenntnis der zukünftigen Anfragen voraus )
-
LFD: (Longest- forward- distance)
Ersetze diejenige Seite, deren nächste Anfrage am weitesten in der Zukunft
liegt.
2. Online Strategien : (unabhängig von zukünftigen Anfragen)
-
LRU: (least- recently- used)
Ersetze diejenige Seite, deren letzte Anfrage am längsten zurückliegt.
-
FIFO: (First- in –First- out)
Ersetze diejenige Seite, die sich am längsten im Cache befindet.
-
LIFO: (Last- in- first- out)
Ersetze diejenige Seite, die als letzte in den Cache geladen worden ist
-
LFU: (Least- frequently –used)
Ersetze diejenige Seite, die, seitdem sie sich im Cache befindet, am wenigsten
angefragt worden ist.
-
FWF: (Flush- when- Full)
Wenn ein Seitenfehler entsteht und der Cache voll ist leere Cache vollständig
und lade Seite in den leeren Cache.
Diese Strategien sind unterschiedlich vielversprechend.
Wir brauchen also einen „Faktor“, um diese zu vergleichen.
Man kann beweisen:
FIFO, LRU, FWF sind k- kompetitiv und daher optimal in der reinen kompetitiven
Analyse, was aber im Gegensatz zu dem steht, was man in der Praxis beobachten kann
(Abb.1).
3
FWF ist in der Praxis ein relativ
schlechter Algorithmus, obwohl die
reine kompetitive Analyse sagt, dass
FWF nicht schlechter als FIFO und
LRU ist.
Jedoch ist in der Praxis LRU
wesentlich besser als FIFO und FWF.
Das wirft die Frage auf:
Wie kommt es zu dieser Differenz
zwischen Praxis und Theorie?
Abb. 1: entstanden aus empirische
Forschungen Quelle: Young
Um nun die Theorie der Praxis näher zu bringen führt die Theorie das Access Graphen
Modell ein.
2.Access Graphen Modell
2.1. Modellbeschreibung : Definitionen und Zielsetzung
Definition: (Access Graph)
Sei G = ( V , E ) ein gerichteter oder ungerichteter N-KnotenGraph (Abb.2), wobei die Knotenmenge die Seiten im
langsamen Speicher und die Kanten die erlaubten
Folgeanfragen darstellen.Wir nennen G einen Access Graphen,
wenn wir G zum spezifizieren von erlaubten Seitenanfragen
benutzen können.
Abb. 2: Access Graphen
Dies modelliert im Access Graphen Modell die Lokalität von Referenzen.
Definition: (konsistente Anfragesequenz)
Die Anfragesequenz σ = r 1 r 2.......r n ist konsistent mit dem Access Graphen G, wenn
( r i , r i+1) ∈ E ∀ i mit ( 1 ≤ i < n ).
Definition: (c-kompetitiv für Graphen)
Sei G = ( V , E ) ein Access Graph und ALG ein Paging-Algorithmus.
O. B. d. A. nehmen wir an, dass alle Access Graphen zusammenhängend sind und k die Größe
des Caches ist.
Wir nennen ALG c- kompetitiv genau dann, wenn es eine Konstante α gibt, s.d.:
ALG ( σ ) ≤ c OPT ( σ ) + α
∀ σ konsistent mit G.
4
Definition: (Kompetitiver Faktor eines Algorithmus)
Der kompetitiver Faktor von ALG auf G, i. Z.: ℜ(ALG,G) ist das Infimum über alle c, so dass
ALG auf G c- kompetitiv ist.
Definition: (Kompetitiver Faktor für einen Access Graphen G)
Wir definieren uns: ℜ(G) : = min ALG ℜ(ALG,G)
Wenn nun für ein gegebenes G und für jedes k gilt:
ℜ(ALG,G) = ℜ(G), dann bezeichnen wir ALG als optimal.
2.2. Zielsetzung
Wir suchen in den folgenden Abschnitten Algorithmen, die für bestimmte Access Graphen G
eine deutlich bessere Kompetitivität als k erreichen.
Dabei werden zusammenhängende, aber keine vollständigen Access Graphen betrachtet, da
wir sonst bei der reinen kompetitiven Analyse bleiben könnten, wo man nach jeder
Seitenanfrage jede Seite anfragen darf, was einem vollständigen Access Graphen entsprechen
würde.
Zur Vereinfachung setzen wir dafür die Cachegröße des Offline Algorithmus gleich der des
Online Algorithmus.
2.3. Theoretische Berechenbarkeit
Die theoretische Berechenbarkeit ist durch das Theorem 1 gegeben, das wie folgt lautet:
Theorem 1:
Sei G ein beliebiger N-Knoten Access Graph.
Es existiert ein berechenbarer deterministischer Online Algorithmus ALG, s.d.:
ℜ(ALG,G) = ℜ(G) ist.
Beweis (Skizze) :
Sobald wir eine obere Schranke für den optimalen kompetitiven Faktor haben, kommen wir
mit einem Algorithmus der nur endlich viel Speicher braucht aus.
Bei einem Paging Problem mit maximal P möglichen Cache-Konfigurationen ist, wenn man
z.B. k Cache-Seiten und N Seiten langsamen Speicher hat,
N
P≤
≤ Nk .
k
Wir nehmen an, dass es einen c-kompetitiven Algorithmus gäbe, der dieses Problem löst.
Dann benötigt man maximal (3c+2) P Speicherzustände. Da k eine obere Schranke für jeden
beliebigen Access Graphen ist, beschränken wir uns auf Algorithmen mit max (3k+2)^Nk
Speicherzuständen und mit maximal T= (3k+2)^Nk x Nk Speicherzustand-CacheKonfigurationspaaren.
Daher verursacht jede Anfragesequenz der Länge T einen Kreis in den Zustandkonfigurationspaaren. Der Gegenspieler muss also den schlechtesten kompetitiven Faktor mit
(
)
5
Sequenzen der Länge ≤ T herausfinden. Somit soll der gesuchte Algorithmus den maximalen
Faktor ALG (σ) / OPT (σ) minimieren, wobei das Maximum über alle Anfragesequenzen der
Länge ≤ T genommen wird.
q.e.d.
2.4. Definition: (Einheitlich kompetitive Algorithmen)
Ein Algorithmus wird einheitlich kompetitiv genannt, wenn es Konstanten b1 und b2 gibt, so
dass für jeden Access Graphen G (und jede Cache Größe k) gilt:
ℜ(ALG,G) ≤ b1 ℜ(G) + b2.
D.h.: Für jeden beliebigen Access Graphen ist der Algorithmus bis auf einen konstanten
Faktor so gut wie der optimale oder best erreichbare Algorithmus.
Wir suchen einen effizienten einheitlich kompetitiven Algorithmus. Effizienz in dem Sinne,
dass jede Online Entscheidung effizient berechnet werden kann mit Rücksicht auf Rechenzeit
und Speicherbedarf.
Nun wollen wir aber zunächst zwei bekannte Algorithmen aus der kompetitiven Analyse
untersuchen.
3. FiFo im Access Graphen Modell
Wir wissen, dass FiFo für Paging in der reinen kompetitiven Analyse k-kompetitiv ist und
daher optimal (!). Jetzt wollen wir zeigen, im Einklang mit dem was man in der Praxis
beobachten kann, dass FiFo die Lokalitäten der Referenzen nicht angemessen ausnutzt. Wobei
die Lokalitäten der Referenzen im Access Graphen dadurch ausgedrückt wird, dass zwei
benachbarte Seiten mit einer Kanten verbunden sind.
Im folgenden untersuchen wir die Qualität vom Algorithmus FiFo, der eine relativ große
untere Schranke für den kompetitiven Faktor hat. Dafür brauchen wir noch eine Definition.
3.1. Definition:(k-Phase)
Wir teilen die Anfragesequenz σ in Phasen ein.
Phase null ist die leere Sequenz.
Für jedes i ≥ 1 ist Phase i die längste Sequenz die Phase i-1 folgt und höchsten k verschiedene
Seitenanfragen enthält.
3.2. Theorem 2.: (Untere Schranke für FiFo)
Für jeden beliebigen zusammenhängenden N-Knoten-Graph mit N > k gilt:
ℜ( FiFo , G ) ≥ ( k + 1 ) / 2.
Um das Theorem zu beweisen, brauchen wir noch folgendes Lemma.
Lemma:
6
Sei H ⊆ G ein Teilgraph von G, daraus folgt ℜ( FiFo , G ) ≥ ℜ( Fifo , H ).
Beweis:(durch Widerspruch):
Wir nehmen an, ℜ( FiFo , G ) < ℜ( Fifo , H ). Wir wählen eine Anfragesequenz σH auf H, für
die die Komplexität von FiFo auf H maximal ist. FiFo hat laut Annahme angewandt auf σH
eine schlechtere Komplexität als FiFo angewandt auf jedes σG auf G.
Somit wäre FiFo(σH) > FiFo (σG ) ein Widerspruch, da auch σH auch konsistent zu G ist.
Beweis(Theorem 2):
Es ist ausreichend das Theorem für einen (k+1)-Knoten-Teilgraph H von G zu beweisen.
Abb. 3: Graph G mit Teilgraph H und Artikulationspunkt w
Also ist zu zeigen, dass ℜ( FiFo , H ) ≥ ( k + 1 ) / 2.
Jeder verbundene Graph H hat mindestens einen Knoten w (Abb.3) , der kein
Artikulationspunkt ist. Ein Artikulationspunkt ist ein Punkt, dessen Entfernung den Graphen
in mehrere Teilgraphen aufspalten würde. Jeder Knoten von H, der aktuell nicht im Cache ist,
bezeichnen wir als Cache-Loch. Wir können davon ausgehen, dass es exakt ein Loch gibt,
weil wir k + 1 Knoten in H haben und FiFo ein Demand-Paging ist, d.h. der Algorithmus
verdrängt nur auf Anforderung.
Beim Beginn jeder Phase ist w die zuletzt eingelagerte Seite im Cache und das Loch ist ein
Knoten v 1 , der benachbart zu w ist. Wir nehmen an v 1 , v 2 , ……… sei die Folge der
Löcher, die während einer Phase entstehen und damit Anfrageziele des Gegners sind.
Angenommen das Loch sei ein Knoten v i ≠ w. Der Gegenspieler wird dann v i anfragen und
FiFo wird, seiner Definition nach, den Knoten v i+1 verdrängen, wodurch das Cache-Loch zum
Knoten v i+1 springt. Wenn nun i < k ist, dann ist v i+1 ≠ w. Der Gegenspieler fragt dann die
Knoten auf einem Pfad des Graphen H von v i nach vi+1 an, ohne Knoten w anzufragen. Dies
ist möglich, da w kein Artikulationspunkt ist. Das Verhalten von FiFo verändert sich nicht, da
die Reihenfolge, in welcher die aktuellen Seiten in den Cache geladen wurden, nicht durch
das wiederholte Anfragen von Seiten entlang dieses Pfades verändert wird. Erreicht das Loch
v k ≠ w (und FiFo hat k-1 Seitenfehler verursacht) dann ist w die nächste Seite, die am
längsten im Cache ist. Der Gegenspieler fordert v k an (k Seitenfehler) und bewegt somit das
Loch von v k nach w. Der letzte Fehler (k+1 Seitenfehler) bei Knoten w, bringt das Loch
zurück zu Knoten v1 und macht w zu der zuletzt in den Cache eingelagerte Seite. Nun sind wir
wieder am Anfang, die Sequenz, wo wir die Löcher v 1 , v 2………v k w hatten, ist
durchgearbeitet. Während so einer Sequenz verursacht FiFo also exakt k+1 Seitenfehler.
OPT kann alle Anfragen der Sequenz mit nur 2 Seitenfehlern bearbeiten, nämlich durch
Verdrängen von Knoten w um v1 zu laden und durch Verdrängen von Knoten v1 um w zu
laden. Also ist ℜ( FiFo , H ) ≥ ( k+1 ) / 2.
7
q.e.d.
3.3. Spezialfall: FiFo auf Knotenlinie
Nun betrachten wir einen Spezialfall, wo FiFo auf einem relativ einfachen Graphen bereits
k-kompetitv ist.
Corollar1:
Sei G = LN eine N = ( k + 1 )-Knoten -Linie. Dann ist ℜ( FiFo, LN ) = k.
Beweis:
Seien k + 1 Knoten v 1, v 2 ,v 3 ,v 4 ...... v k+1 = LN durchnummeriert und vk+1 die zuletzt in den
Cache eingelagerte Seite und v2 die zuerst gelagerte Seite.
Betrachte σ = v 1 v 2.......v k vk+1
Abb. 4: (k+1)-Knotenlinie =LN
FiFo macht k Seitenfehler und OPT nur einen. Zusammen mit der allgemeinen oberen
Schranke ergibt sich:
ℜ( FiFo, LN ) = k / 1= k
q.e.d.
4. LRU im Access Graphen Modell
LRU nutzt im Gegensatz zu FiFo, die Lokalitäten von den Referenzen besser aus.
Für jeden Access Graph, der ein Baum ist, ist LRU ein optimaler Online Algorithmus.
Bäume, die auch häufig in andere Datenstrukturen eingebettet sind, liegen vielen
Datenstrukturen als Access Graphen zugrunde.
Wenn G ein Baum ist, dann können wir eine einfache, präzise Charakterisierung von ℜ( G )
herleiten.
Dazu sei für jeden zusammenhängenden Graphen G:
Ti ( G ) = { T | T ist ein Teilbaum von G mit i Knoten }
Und für jeden Baum
L ( T ) die Anzahl der Blätter von T.
4.1. Obere und untere Schranke für LRU
Zuerst die allgemeine untere Schranke:
Theorem 3:
Sei G ein beliebiger Graph mit N ≥ ( k + 1 ) Knoten, dann ist :
ℜ( G ) ≥ max T ∈ Tk+1( G ) { L ( T ) – 1 }
8
Beweis:
Sei ALG ein beliebiger deterministischer Algorithmus.
Nun wählt der Gegenspieler einen geeigneten Baum T
aus. ( Abb. 5 ) Damit alle inneren Knoten im Cache sind,
legt der Gegenspieler sein OPT -Loch auf ein Blatt von T.
D.h. alle inneren Knoten von T sind im optimalen OfflineCache vom Gegenspieler. Somit kann der „böse“
Gegenspieler das ALG –Loch anfragen, indem er auf T
entlang geht. So macht ALG auf jedem Blatt einen
Seitenfehler. Wohingegen OPT, pro L( T ) - 1 Blätter die
beim benutzen der LFD Strategie angefragt werden, auf
den Blättern von T maximal einen Seitenfehler macht.
Abb.5: Baum T mit OPT-Loch auf Blatt
q.e.d.
Im Gegensatz zu der Ausführung von FiFo, lässt das soeben bewiesene Theorem die
Möglichkeit offen, dass ℜ( G ) = 1 ist, wenn wir eine Access Graphen Linie LN mit N ≥ k+1
Knoten haben.
Für jeden Baum G zeigen wir, dass LRU die dichte (zum Theorem 3) obere Schranke erreicht,
indem wir die folgende amortisierende Kostenanalyse („amortized charging technique“) auf
das Paging anwenden.
Lemma 1: (Amortisierende Kostenanalyse („Amortized charging technique“))
Wir nehmen an, dass wir immer wenn OPT ein Fehler macht, höchstens c Token auf den
Knoten von G verteilen. Falls es möglich ist, bei jedem ALG Fehler einen Token zu streichen,
dann ist ALG c-kompetitiv auf G.
Beweis
Man sieht direkt, dass das Lemma stimmt. Der Gebrauch der Token demonstriert klar, dass es
für jeden OPT Fehler maximal c ALG Fehler gibt.
q.e.d.
Jetzt zeigen wir, dass LRU auf jedem Baum die allgemeine untere Schranke erreicht.
Theorem 4:
Sei G irgendein Baum. Dann gilt:
ℜ( LRU , G ) = max T ∈ T k+1( G ) { L ( T ) – 1 }
Beweis:
Wir wissen, dass LFD ein optimaler Offline Algorithmus ist.
Wir betrachten zu allen Zeitpunkten t die folgende Menge von
Knoten aus G ( Abb.6 ): Die der t- ten Anfrage r t und die k Seiten,
die vor Erfüllung der Anfrage aktuell im Cache von LRU (bzw. von
LFD) sind. Diese Menge ist (einfache Induktion über t) ein
Teilbaum von G, den wir als Baum t [LRU] (bzw. Baum t [LFD] )
bezeichnen.
Abb. 6: Baum [LRU];Baum [LFD] und einsame Seiten
9
Macht LRU ( oder LFD) einen Fehler, entsteht dieser auf einem Blatt des jeweiligen Baumes.
Die jeweilige Strategie bedient diesen Fehler, indem eine Seite aus dem Cache entfernt wird,
die einem Blatt des jeweiligen Baumes entspricht.
Wir verteilen bei jedem Fehler maximal max T ∈ T k+1( G ) { L ( T ) – 1 } Token auf die Seiten
im Cache von LRU (wie Lemma 2 zeigen wird). Die verdrängte Seite besitzt bei jedem LRU
Fehler (wie Lemma 3 zeigen wird) einen Token, der dann zerstört wird, um den Fehler zu
bezahlen.
So erhalten wir die gewünschte Grenze von ℜ ( LRU, G).
Zum Beweis von Lemma 2 und 3 führen wir das Token Charging Schema ein:
Token Charging Schema:
Betrachte einen LFD Fehler an der t- ten Nachfrage r t.
Folge für jedes Blatt v ≠ r t im Baum t [LRU] dem Pfad von v zu r t und platziere einen Token
auf den ersten Knoten (=Seite im Cache von LRU) welcher noch keinen Token hat.
Abb.7: LFD Fehler an der t- ten Nachfrage r t
Abb. 8: Nach dem LFD-Fehler
In den Abbildungen 7 und 8 bezeichnen die Knoten, die innen weiß sind haben einen Token.
Der Beweis Theorem4 ist fertig, wenn wir die folgenden beiden Lemmata beweisen.
Lemma 2.:
Bei einem LFD Fehler werden maximal L ( Baum t [LRU] ) - 1 Token durch das Charging
Schema verteilt.
Wir nehmen noch zur Kenntnis, dass das Charging Schema garantiert, dass höchstens
L ( Baum t [LRU] ) Token verteilt werden.
Vor dem Beweis von Lemma 2 brauchen wir noch einen Begriff:
Einsame LRU (bzw. LFD)Seite:
Wir nennen u eine einsame LRU (bzw. LFD) Seite, wenn der Knoten im Cache von LRU ist
(bzw. von LFD) aber nicht im Cache von LFD ( bzw. LRU). Siehe Abb. 6 )
Beweis:
1.Fall:Wenn die Nachfrage r t ein Blatt von Baum t [LRU] ist
( Abb.9 ), dann ist klar, dass das Lemma gilt.
Abb. 9: Baumt[LRU] mit Knoten rt als Blatt und L( T )-1 Blättern.
10
2.Fall: Jetzt brauchen wir nur noch die Fälle zu betrachten, bei denen
r t ein innerer Knoten von Baum t [LRU] ist (Abb. 10). Also bleibt zu
zeigen, dass es ein Blatt v von Baum t [LRU] gibt, so dass jeder
Knoten auf dem Pfad von v nach r t schon einen Token besitzt.
Abb. 10: Baumt[LRU] mit Knoten rt als innere Knoten
Macht LFD einen Fehler an einem der Blätter r t von Baum t [LFD]
und ist dies ein innerer Knoten vom Baum t [LRU] (Abb. 11 ), dann
ist r t eine einsame LRU Seite. Dann gibt es auch einen Pfad von r t
zu einem Blatt von Baum t [LRU] s.d. alle Knoten auf diesem Pfad
einsam sind.
Abb. 11: Baum [LRU/LFD] mit Knoten rt, der einsamen Knoten im Baum [LFD] ist.
Nun reicht es durch Induktion über t zu zeigen, dass jede einsame LRU Seite einen Token
besitzt.
Induktionsanfang: ( t = 1 )
LFD und ALG haben laut Vorraussetzung vor dem ersten Schritt die selben k Seiten im
Cache. Daraus folgt, wenn t = 1 ist gibt es keine einsamen LRU Seiten.
Induktionsvoraussetzung:
Zum Zeitpunkt t besitzt jede einsame LRU Seite einen Token.
Induktionsschluss: (t → t +1)
Wir nehmen an die Annahme sei vor der t- ten Nachfrage erfüllt. Wir zeigen nun, dass sie
nach der t- ten Nachfrage immer noch erfüllt ist.
Eine Seite u im Baum t [LRU] kann nur eine einsame LRU Seite werden, wenn LFD einen
Fehler an r t macht und u verdrängt um r t zu bedienen.
Aber dann gibt es immer einen Pfad von r t zu irgendeinem Blatt v im Baum t [LRU], welcher
durch u verläuft.
Es ist möglich, dass u das Blatt ist. Dann ist v = u.
Ansonsten muss auf dem Pfad von u nach v jeder Knoten u´ ≠ u auch einer einsamen LRU
Seite entsprechen und deswegen (nach der Induktionsvoraussetzung ) einen Token besitzen.
Das Charging Schema platziert dann einen Token auf u, außer wenn u schon einen hat.
q.e.d.
Nun beweisen wir folgendes Lemma, welches (vgl. Lemma 1) die Kompetitivität von LRU
beweist, womit der Beweis von Theorem 4 fertig ist.
Lemma 3:
Immer wenn LRU eine Seite u verdrängt (im Baum t [LRU]) um einen Fehler zu bedienen,
besitzt u einen Token.
Beweis:
Wir betrachten den Zeitpunkt t1 kurz bevor u von LRU verdrängt wird wo u die am längsten
nicht mehr benutzte Seite wird. Wir sind fertig, wenn u zu diesem Zeitpunkt t1 einen Token
besitzt.
Daher nehmen wir an, u würde keinen Token zur Zeit t1 besitzen.
11
Wenn LFD gleichzeitig mit LRU einen Fehler macht oder wenn LFD vor LRU den nächsten
Fehler macht, sind wir auch fertig.
Da das Charging Schema zuerst einen Token auf u platziert, da u ein Blatt im Baum t1 [LRU]
ist. Allerdings könnte der nächste LRU Fehler vor dem nächsten LFD Fehler an einer
einsamen LFD Seite auftreten.
Entfernt man die Knoten von dem Baumt1 [LRU] (außer u), so zerschneidet man G in
Teilbäume. Sei T (u) der Teilbaum, der u enthält.
Es reicht zu zeigen das zum Zeitpunkt t1 alle einsamen LFD Seiten in T(u) sind.
Dieses würde sicher stellen, dass u zu einem gewissen Zeitpunkt nach t1 vor einer beliebigen
einsamen LFD Seite angefragt wird. Dann wäre u nicht mehr die am längsten nicht benutzte
Seite.
Dies steht im Widerspruch zu der Annahme, dass t1 der letzte Zeitpunkt ist, (bevor u
verdrängt wird) an dem u die am längsten nicht mehr benutzte Seite wird.
Sei I das Zeitintervall ( t0, t1 ], wobei t0 < t1 ist und u wurde das letzte Mal im Zeitpunkt t0
angefragt.
Nun müssen auch alle Knoten außer u im Baumt1 [LRU] angefragt worden sein, damit u der
am längsten nicht benutzte Knoten zum Zeitpunkt t1 ist. Die folgenden Ungleichungen zeigen,
dass alle einsamen LFD Seiten in T(u) sind.
(
Anzahl von LFD
Seiten in T(u)
zum Zeitpunkt t0
)≥(
Anzahl von LRU Seiten
ohne Token in T(u) zum
Zeitpunkt t0
)
Anzahl der Token die auf
T(u) während I gesetzt
wurden
)
Jede einsame LRU Seite hat einen Token
≥
(
Keine Seite aus T(u) wird zweimal angefragt =>Kein Knoten kann mehr als einen Token bekommen.
≥
(
Anzahl von LFD Fehlern
während I
)
Baum t[LRU]hat in T(u) zu jedem Zeitpunkt t ∈ I ein Blatt. Weil u keinen Token erhält, muss es einen anderen
Knoten auf dem Pfad von v nach u geben, der einen Token erhält.
(
≥ (
≥
Anzahl von LFD Seiten,
die während I aus T(u)
verdrängt wurden
Anzahl von LFD Seiten,
die während I aus T(u)
verdrängt wurden
+
Anzahl von LFD Seiten
nicht aus T(u) die während I
verdrängt wurden
+
Anzahl von einsamen LRU
Seiten zum Zeitpunkt t1
) (
) (
)
)
Es gibt zum Zeitpunkt t1 keine einsamen LRU Seiten in T(u), weil u (kein Token => nicht einsam) die einzige Seite
in T(u) ist. Jede einsame LRU Seite zum Zeitpunkt t1 ist im Baum t1[LRU] und wurde während I angefordert Damit
eine solche Seite einsam ist, muss LFD sie während I verdrängt haben.
Also gilt:
(
≥ (
Anzahl von LFD Seiten
in T(u) zum Zeitpunkt t0
Anzahl von LFD Seiten,
die während I aus T(u)
verdrängt wurden
)
) (
+
Anzahl von einsamen LRU
Seiten zum Zeitpunkt t1
)
Und auch:
12
(
≥ (
Anzahl von LFD Seiten
in T(u) zum Zeitpunkt t0
Anzahl von einsamen
LRU Seiten zum
Zeitpunkt t1
)-(
)
Anzahl von LFD Seiten, die
während I aus T(u)
verdrängt wurden
)
Anzahl von LFD Seiten, die
während I aus T(u)
verdrängt wurden
)
)
Daher gilt:
(
= (
= (
Anzahl von LFD Seiten
in T(u) zum Zeitpunkt
t1
Anzahl von LFD Seiten
in T(u) zum Zeitpunkt t0
Anzahl von einsamen
LRU Seiten, zum
Zeitpunkt t1
)
)- (
)=(
Anzahl von einsamen LFD
Seiten zum Zeitpunkt t1
Alle einsamen LFD Seiten müssen in T(u) sein.
q.e.d.
4.2. Spezialfall: LRU auf Knotenlinie
Es ergibt sich sofort das folgende Corollar, das auch ein extremes Beispiel dafür darstellt,
dass LRU viel besser als FiFo sein kann.
Corollar 2.:
Für jede Linie G ist ℜ( LRU , G ) = ℜ( G ) = 1
Beweis:
O.B.d.A. sei N > k. Jeder Teilbaum mit k+1 Knoten hat bis zu 2 Blätter. Eins wenn die
Wurzel am Ende der Linie liegt, ansonsten 2. Es ist ausgeschlossen, dass es mehr als 2 Blätter
sind, da G dann keine Linie mehr ist. Aus der obigen Formel folgt sofort die Behauptung.
q.e.d.
4.3. Vergleich: LRU gegen FiFo
Des Weiteren ist LRU auf einem beliebigen Access Graphen immer mindestens so gut wie
FiFo, was das folgende Theorem besagt:
Theorem 5:
Für einen beliebigen Access Graphen G ist (ohne Beweis)
ℜ( LRU , G ) ≤ ℜ( FIFO , G ).
13
Es sei noch mal darauf hingewiesen, dass LRU auf Bäumen optimal ist, aber auf anderen
Graphen deutlich schlechter abschneiden kann.
Ein Beispiel wird in Theorem 6 angeführt.
Theorem 6:
Sei CN ein Kreis mit N = k + 1 Knoten.
Dann ist:
ℜ( LRU , CN ) = ℜ( FIFO , CN ) = k
Beweis:
Der Gegenspieler verlangt die Knoten von CN im (oder gegen
den) Uhrzeigersinn. So machen FIFO und LRU bei jeder
Anfrage einen Fehler wobei LFD einen Fehler alle k Anfragen
macht. (Abb. 12 )
q.e.d.
.
Abb. 12: (k+1) Knoten Kreis
5. Algorithmus FAR
Nun endlich zu einem einheitlich kompetitiven Algorithmus.
Hier zunächst auf einem Kreis.
5.1. FAR (eingeschränkt auf einen (k + 1) Knoten Kreis CN):
Nun betrachten wir den Markierungsalgorithmus FAR.
Hierbei sind während einer k-Phase die markierten und unmarkierten Knoten des Kreises
Pfade auf dem Kreis CN, sprich Bögen.
Tritt ein Seitenfehler auf, wird die Seite, die gerade in den Cache geladen wurde markiert. Die
Seite, die auf dem Mittelpunkt des Pfades der jetzt unmarkierten Seiten liegt wird verdrängt.
Im folgenden werden wir eine obere und untere Schranke für FAR beweisen.
Obere und untere Schranke für Algorithmus FAR auf einem Kreis
Theorem 7:
Sei CN ein N = ( k + 1 ) Knoten Kreis. Für FAR gilt dann:
ℜ( FAR , CN ) = ℜ( CN ) = log(k + 1)
14
Nun zum Beweis der oberen Schranke von FAR ( Abb. 13 ) auf einem Kreis.
Beweis:
Der Algorithmus FAR macht maximal 1+  log k  Fehler in einer Phase.
Zu Beginn einer Phase gibt es k unmarkierte Knoten (s. ersten Kreis von
Abb. 13 ).
Ist eine Phase zu ende, wird der erste Knoten der neuen Phase markiert und
die Knoten die in der alten Phase markiert waren verlieren gleichzeitig ihre
Markierung. ( s. zweiten Kreis von Abb. 13 )
Der Gegenspieler muss somit mindestens die Hälfte der unmarkierten
Knoten anfragen und damit auch markieren, um den unmarkierten Knoten
der im Cache nicht präsent ist anzufragen / aufzurufen.( s. dritter Kreis von
Abb. 13 ).
Bis der letzte unmarkierter Knoten aufgerufen wird, muss der Algorithmus
FAR den eben beschriebenen Prozess (unmarkierte Knoten anfragen die im
Cache sind bis unmarkierten Knoten der nicht im Cache ist erreicht wird)
maximal log k  mal durchführen. ( s. vierter Kreis von Abb. 13 )
Dieser unmarkierte Knoten der nicht im Cache ist wird der erste Fehler
gemeinsam mit den Beginn einer neuen Phase sein.
Nun wissen wir ja schon von Theorem 3.2., dass jeder Algorithmus, also
auch der optimale Algorithmus mindestens einen Fehler pro Phase machen
muss.
Daher ist ℜ( FAR ,CN) ≤ log (k+1)
( Abb. 13: FAR auf einem Kreis )
Die obere Schranke von FAR motiviert uns zu einer allgemeinen unteren Schranke ℜ(ALG,
CN) ≥ log (k+1). Bevor wir zum Beweis kommen sei noch mal in Erinnerung gerufen:
Das k-Phasen Modell bei Markierungsalgorithmen ist wohldefiniert, unabhängig davon
welchen Algorithmus wir haben.
Weiterhin gilt ein Knoten als markiert, wenn er während einer Phase angefragt wurde und
unmarkiert, wenn er nicht angefragt wurde
Beweis:
Sei ALG ein beliebiger Online Algorithmus und die Situation die
folgende:
Zu Beginn einer Phase haben beide Algorithmen (der OPT und ALGAlgorithmus) ihr Cache Loch beim selben Knoten und es gibt wie immer
einen markierten Knoten und somit k unmarkierte Knoten. (Abb. 14 )
(Abb. 14: Beginn einer k-Phase)
15
Wenn ALG jemals einen markierten Knoten verdrängt, dann wird der Gegenspieler immer
diesen Knoten entlang eines markierten- Knoten- Pfades anfragen und damit seine Kosten
nicht erhöhen.
Also können wir annehmen, das ALG sich auch wie ein Markierungsalgorithmus verhalten
muss.
Der Gegenspieler wird dann weiterhin das Cache Loch von ALG versuchen anzufragen,
indem er den Pfad von CN entlang läuft, der die wenigsten unmarkierten Knoten hat, bis er auf
nur einen unmarkierten Knoten gelangt. Diesen betritt der Gegenspieler dann zu Beginn einer
neuen Phase.
Klar ist dann, dass ALG mindestens log (k+1) Fehler pro Phase macht und OPT genau
einen.
q.e.d.
5.2. FAR: Ein einheitlich kompetitiver Paging-Algorithmus
Den Algorithmus FAR kennen wir schon vom ( k + 1 ) Knoten Kreis. Dort konnten wir FAR
einfach als online Approximation des optimalen Offline Algorithmus LFD ansehen. Im
folgenden ist mit Lokalität von Referenzen nicht mehr die Nachbarschaft von zwei Knoten
gemeint, sondern diese Knoten sind benachbart, die markierten sind. Von den unmarkierten
Knoten wird der Knoten verdrängt, der graphtheoretisch von den markierten Knoten am
weitesten entfernt liegt. D.h. wir approximieren „zeitlich am weitesten weg“ (=LFD) mit
„graphtheoretisch am weitesten weg“ (= FAR).
Algorithmus FAR:
Sei G ein beliebiger ungerichteter Graph. Sei M die Menge von markierten Knoten (zu jeder
Zeit während einer k-Phase) einschließlich der aktuellen Anfrage. FAR verdrängt eine
unmarkierte Seite u, wenn die aktuell angefragte Seite nicht im Cache ist, so dass die Distanz
auf G zwischen M und u ( i.Z. distG( M , u ) ) maximal ist. Das bedeutet, dass für jeden
Knoten v der nicht markiert ist gelten muss:
distG(M , v) ≤ distG(M , u), wobei distG(M , v) := min {distG(z , v) | z ∈ M}.
Nun werden wir beweisen, dass FAR einheitlich kompetitiv ist, d.h.:
ℜ( FAR , G ) = O( ℜ( G ) ) für jeden Access Graphen G.
Sei σ eine Anfragesequenz. Wir betrachten seine k-Phasen-Einteilung.
Eine „neue“ Seite in einer Phase ist eine, die in der vorherigen Phase nicht angefordert wurde.
Des Weiteren ist OPT( σ ) ≥ ∑ m i / 2 wobei m i die Anzahl der neuen Seiten in der i- ten
Phase ist. Wir wollen nun zeigen, dass FAR (asymptotisch gesehen) optimal in jeder Phase
ist. Genauer gesagt, dass für eine Konstante c gilt:
Theorem 9:
Sei σ ( i ) die i-te Phase. Dann ist:
FAR( σ ( i ) ) ≤ c ℜ ( G ) mi ≤ c ℜ ( G ) OPT( σ ( i ) )
und als unmittelbare Folgerung ergibt sich:
FAR( σ ) = O ( ℜ ( G ) OPT( σ ) ).
16
Bevor wir dieses Theorem beweisen kommen noch ein paar Definitionen und ein Beispiel zur
Rebenzerlegung sowie ein Theorem, was eine geeignete untere Schranke zum Beweis von
Theorem 9 liefert.
Definition: Rebenzerlegung (vine decomposition)
Eine Rebenzerlegung V ( H ) = ( T , P ) von einem zusammenhängenden Graph besteht aus
einem Baum und einer Ansammlung von einfachen Pfaden P = (P1 , P2 , .... P q ). Die Knoten
von H werden in diejenigen des Baumes T und in die inneren Knoten der Pfade Pi aufgeteilt.
Die Pfade werden Reben (vines) und die Endpunkte der Pfade (im Baum) Anker (anchor)
genannt.
Sei nT die Anzahl von Blättern in T, die keine Anker sind.
Definition des Wertes einer Rebe Pi :
val( Pi ) = log ( Anzahl von Kanten in Pi )
Definition des Wertes einer „Rebenzerlegung“ V ( H ):
val ( V ( H ) ) = ∑i=1..q val (Pi ) + nT – 1
Beispiel 1 (Rebenzerlegung):
In diesem Bild haben wir eine Rebenzerlegung V ( H ) = ( T , P )
von einem 4 x 4 Maschenarray H.
Es ist nun
val ( V ( H ) ) = val( P1 ) + val( P2 ) + nT – 1 = 2 + 2 + 4 – 1 = 7
(Abb. 14: Die gestrichelten Linien sind die Pfade und die durchgezogenen Linien
bilden den Baum.)
Hier zuerst eine untere Schranke, die wir durch Erweiterung des Beweises von Theorem 7
erhalten.
Theorem 10:
Sei G ein N-Knoten Graph und enthalte G einen Kreis mit (k + g) Knoten als Teilgraphen
(1 ≤ g ≤ k). Dann ist
ℜ( G ) ≥  log k – log g  / 2.
Diese Schranke verknüpfen wir in Theorem 11 mit der Schranke der Anzahl von Blättern
eines k+1 Knoten Teilbaumes.
Theorem 11: Untere Schranke für eine Rebenzerlegung (vine decomposition):
Sei G ein zusammenhängender Graph mit N ≥ ( k + 1) Knoten,
H ein (k + 1) Knoten zusammenhängender Teilgraph von G mit einer Rebenzerlegung V( H ).
Dann ist ℜ( G ) ≥ val ( V ( H ) ).
17
Beweis:
Sei ALG ein beliebiger Online Algorithmus. Der Gegenspieler schränkt alle Anfragen auf H
ein und wird so höchstens einen Seitenfehler pro k-Phase verursachen.
Es bleibt zu zeigen, dass der Gegenspieler von ALG mindestens val ( V ( H ) ) Seitenfehlern
pro Phase erzwingen kann.
Das ALG- Loch wird vom „bösen“ Gegenspieler so effizient wie möglich angefragt. Befindet
sich das ALG- Loch auf einen Knoten im Baum, läuft der Gegenspieler auf markierten oder
bauminternen Knoten zu diesem. Ist das ALG- Loch ein innerer Knoten einer Rebe , dann
läuft der Gegenspieler zu diesem Knoten, indem er markierte Knoten, bauminterne Knoten,
Anker und höchstens die Hälfte der unmarkierten Knoten von Pi benutzt.
Es ist klar, dass das Loch während einer Phase an jedem der nT nicht- Anker-Blätter auftaucht
und mindestens val( Pi ) mal an jeder Rebe Pi.
q.e.d.
Wir bezeichnen val ( H ) =  log k – log g  wenn H ein (k + g) Knoten Kreis ist. Weiterhin
definieren wir, wenn H ein zusammenhängender Graph mit k+1 Knoten ist welcher kein Kreis
ist val ( H ) = max V(H) ( val ( V ( H ) ) ).
Beweis von Theorem 9:
Wir müssen zeigen, dass es für die i-te Phase σ ( i ) mit m = mi neuen Knoten einen
Teilgraphen H gibt, s.d.:
val ( H ) ≥ (δ / m ) FAR ( σ ( i ) ) für irgendein δ = 1 / c > 0 gilt.
Somit muss H entweder ein Kreis sein oder eine geeignete Rebenzerlegung haben.
Betrachte die Sequenz von Knoten, d.h. Seiten die während einer Phase verdrängt wurden und
teile die Sequenz in Blöcke von m+1 aufeinander-folgenden Knoten auf. Wir nehmen an es
gäbe R Blöcke und zeigen dann, dass es ein H gibt mit val ( H ) ≥ δ R.
Wir wählen einen repräsentativen Knoten für jeden Block. Die Anzahl von Knoten die
während einer Phase verdrängt und momentan außerhalb des Caches sind, ist höchstens m, da
es m neue Knoten in der Phase gibt.
Da es m+1 Knoten in einem Block gibt, muss mindestens ein Knoten des Blockes markiert
sein bevor irgendein Knoten im nächsten Block verdrängt wird. Wir suchen uns einen solchen
Knoten aus und nennen ihn rep.
Die R reps werden nun in zwei Kategorien eingeteilt. So können wir die Existenz eines
Teilgraphen mit Wert Ω ( R ) zeigen.
Wir betrachten die V Knoten die während einer Phase markiert werden. Die Markierungsreihenfolge definiert einen gerichteten Baum T = ( V , E ) mit k Knoten. In diesem Baum
existieren gerichtete Kanten < u , v >, genau dann wenn die erste Anfrage an v direkt einer
Anfrage an u folgt. Der erste Knoten, der in einer Phase markiert wird, ist die Wurzel von T.
Eine Kette in T ist ein gerichteter Pfad in T dessen interne Knoten alle Grad 2 in G haben
(Solche Knoten nennt man Kettenknoten) und dessen Endpunkte keine Kettenknoten sind. Ein
nicht Kettenknoten ist entweder die Wurzel von T oder ein Blatt in T oder hat Grad ≥ 3 in G.
Ketten sind gute Kandidaten für Reben in der Rebenzerlegung, die wir konstruieren wollen.
Ein rep ist vom Typ 1, wenn er kein Kettenknoten ist oder wenn er einer der ersten 4 reps in
einer Kette ist oder wenn er der letzte rep in einer Kette ist. Ansonsten ist er ein rep vom Typ
2. Wir benutzen folgende zwei Lemmata, um den Beweis zu vollenden. (Beweise der
Lemmata siehe Anhang [1] )
18
Lemma 4:
Wenn es R1 reps vom Typ 1 gibt, dann gibt es einen (k+1) Knoten Teilbaum T’ in G mit
Ω ( R1 ) Blättern. Daher nach Theorem 13 und 3 ist ℜ ( G ) = Ω ( R1 ).
Lemma 5:
Wenn es R2 reps vom Typ 2 gibt, dann gibt es einen Teilgraphen H von G mit
val ( H ) = Ω ( R2 ). Nach Theorem 13 ist ℜ ( G ) = Ω ( R2 ).
q.e.d.
Die beiden Lemmata zeigen, dass es einen geeigneten Teilgraphen von G gibt, so dass aus der
unteren Schranke eines Teilgraphen mit Rebenzerlegung die einheitliche Kompetitivität von
FAR folgt.
6. Zusammenfassung und Ausblick
6.1. FiFo, LRU, FAR
Wir haben gesehen, dass obwohl FiFo in der reinen kompetitiven Analyse optimal ist, FiFo in
vielen Fällen schlecht abschneidet.
Des weiteren haben wir gezeigt, dass LRU in vielen Fällen besser als k-kompetitiv und bei
Bäumen sogar optimal ist.
Als letztes wurde der Algorithmus FAR vorgestellt und wir haben bewiesen, dass er
einheitlich kompetitiv ist.
Allerdings setzte unsere Analyse voraus, dass der zugrundeliegende Access Graph bekannt
ist. Nun werden wir eine Methode kennen lernen, Access Graphen dynamisch zu
approximieren.
6.2. Dynamische Access Graphen
Um universelle Algorithmen wie FAR auf das allgemeine Paging Problem anzuwenden,
müssen wir eine gute dynamische Approximation an den Access Graphen entwickeln.
Eine Art der Erstellung eines dynamischen gewichteten (ungerichteten) Graphen ist folgende:
Umso größer das Gewicht w einer Kante < u , v > ist, desto geringer ist die Chance, dass u
(oder v) die nächste angeforderte Seite nach v (oder u) ist. Dieser Ansatz benutzt diese
Gewichte als Distanzen, was die Idee von FAR indem Sinne erweitert, das man
graphentheoretische Distanzen als Approximation von LFD hernimmt.
Im folgenden eine Art, einen gewichteten Access Graphen G dynamisch zu erzeugen. Die
Knoten von G entsprechen wieder den Seiten. Werden das erste Mal 2 Seiten (u und v)
erfolgreich hintereinander angefordert, dann erstellen wir eine Kante zwischen u und v mit
dem Gewicht 1. Wird dieses Paar erfolgreich hintereinander angefragt, werden wir dessen
Kantengewicht mit einem Faktor α < 1 multiplizieren. Ist das Gewicht dann noch >1, setzen
wir es auf 1. Es werden periodisch, (z.B.: alle λk Anfragen) alle Kanten um einen Faktor β >
1 erhöht. Dadurch berücksichtigt der Graph aktuellere Anfragen besser, da er graduell ältere
Anfragen „vergisst“.
Jeden Paging Algorithmus (z.B. FAR) kann man auf einem Graphen laufen lassen der so
entwickelt wird.
Folgende FAR- Variation ist nach einer experimentellen Studie vielversprechend.
19
6.3. Algorithmus FARL
FARL Algorithmus (Farthest – to – last – request)
Sei G ein gewichteter Access Graph, der von vornherein bekannt sein kann oder durch einen
dynamisch entwickelten Graphen entstanden sein kann. FARL verdrängt bei einem
Seitenfehler die Seite u, so dass distG(v , u) maximal ist.
Wobei v die zuletzt erfolgreich angefragte Seite ist.
FARL ist eine sehr natürliche Approximation an LFD, jedoch kein Markieralgorithmus. Der
kompetitive Faktor von FARL ist, bezogen auf den optimalen offline Algorithmus: θ(k log k).
FARL ist um einiges besser als FAR, der wiederum mit der Performance von LRU zu
vergleichen ist. Eine Erklärung dafür ist, dass das Markieren zwar vor worst-case-Verhalten
schützt, jedoch diese Markierungen eine schlechte Näherung an die in naher Zukunft
gebrauchten Seiten darstellen.
6.4. Fazit
Abschließend sei davor gewarnt, dass obwohl die kompetitive Analyse oft neue Erkenntnisse
in dem wohl meiststudierten online Problem bringt, eine gute Seitenfehlerrate durch erhöhten
Aufwand erkauft werden muss. In dieser Hinsicht ist LRU schon teuer und wird oft durch
CLOCK approximiert. Das Modell der dynamischen Access Graphen beinhaltet nicht
unwesentliche Speicher- und Rechenkosten.
Literaturangaben:
[1]
Allan Borodin Ran El-Yaniv.
Online Computation and Competitive Analysis
Cambridge University Press 1998
[2]
A. Borodin, S. Irani, P. Raghavan and B. Schieber
Competitive paging with locality of reference.
Journal of the Computer and System Sciences, 50(2):244-258, 1995
[3]
S.Irani, A. Karlin and S. Phillips.
Strongly competitive algorithms for paging with locality of references .
SIAM Journal on omputing, 25(3):447-497,1996
[4]
A. Fiat and A. Karlin. Randomized and multifingers paging with
locality of references. In Proceedings of the 27th Annual ACM Symposium on
Theory of Computing, pp. 626-634, 1995
[5]
J.A. Garay, I. S. Gopal, S. Kutten, Y. Mansour, and M. Yung. Efficient on-line
call control algorithms. Journal of Algorithms, 23:180-194, 1997
[6]
M. Chrobak and J. Noga. LRU is better than FiFo. In Proceedings of the 9th
Annual ACM-SIAM Symposium on Discrete Algorithms, pp. 78-81, January,
1998.
20