Access-Modell. A4. Im Operandenteil von Anweisungen vorkommende Objekte seien unstrukturiert und stehen in keinerlei Beziehung zueinander.

Transkript

1 Access-Modell Das Access-Modell beruht auf folgenden vereinfachenden Annahmen: A1. Im Operationsteil einer Anweisung sei nur der Operator Access erlaubt. Die beabsichtigte Semantik ist, daß die Daten aus dem im Operandenteil bezeichneten Objekt in den lokalen Speicher des die Transaktion ausführenden Prozesses gelesen, dann dort verarbeitet und dabei möglicherweise geändert und anschließend in das Objekt zurückgeschrieben werden. A2. Weitere Einzelheiten der Semantik, insbesondere über die Art der Verarbeitung seien nicht bekannt. A3. Nachdem eine Access-Anweisung vollständig ausgeführt ist, werde der lokale Speicher jeweils als gelöscht gedacht, d.h. die Transaktion arbeitet zwischen den Anweisungen ohne lokales Gedächtnis. Ferner bearbeite eine Transaktion jedes Objekt höchstens einmal. A4. Im Operandenteil von Anweisungen vorkommende Objekte seien unstrukturiert und stehen in keinerlei Beziehung zueinander. A5. Alle Transaktionen werden vollständig wirksam. A6. Alle Transaktionen liegen als unverzweigte Anweisungsfolgen textuell als Ganzes vor

2 Access-PlŠne Anweisungen und Transaktionen: A Menge von Operatoren (Aktionen) O Menge von Objekten S := A O Menge der Anweisungen T := { t t : {1,...,n} S, t ist injektiv } Menge der Transaktionen Pläne: Ist T = {t 1,...,t k } eine Menge von Transaktionen mit t i = (t i.1,..., t i.ni ), so heißt 1-1 P: { 1,...,n1+...+nk } { i.j 1 i k, 1 j ni} auf derart, daß für alle i, für alle j1, j2 gilt : j1 < j2 P -1 (i.j1) < P -1 (i.j2) Plan (schedule) zu T. Menge der Operatoren nur A:={Access}. Die Semantik von Access-Plänen behandelt den Operator Access derart, daß jedes Vorkommen eine verschiedene Funktion bezeichnet, diese Funktionen einstellig sind, keine weiteren Kenntnisse über diese Funktionen vorliegen, diese Funktionen damit mit ihren unterschiedlichen Funktionszeichen identifiziert werden können. Semantik von Access-PlŠnen F ist eine Menge von (gemäß Annahme A2 uninterpretierten, Skolem-) Funktionszeichen. Skolem : N N 1-1 F ist eine injektive Zuordnung von Anweisungen in Transaktionen, genauer von den entsprechenden Komponentennummern i.j, zu Funktionszeichen (der Stelligkeit 1 gemäß Annahme A3). f i.j := Skolem (i,j). Für einen Plan P = ( p 1,..., p m ) zur Menge von Transaktionen T = { t 1,..., t k } sei O(T) die Menge der in Anweisungen aus T vorkommenden Objekte. Für o O(T) sei Access (P, o ) die Teilfolge derjenigen p x = i x.j x aus P, für die t i x. j die Form Access o hat. x Die Semantik von P ordnet jedem Objekt o O(T) einen Term über O(T) F zu vermöge eval (P, o ) := o f i.... f 1 j 1 i e. j e mit Access (P, o ) = ( i 1.j 1,..., i e.j e )

3 Endzustand- quivalenz von Access-PlŠnen, Endzustand-Serialisierbarkeit Definition 1. Seien P und P Access-Pläne zu einer Menge von Transaktionen T. P ist Endzustand-äquivalent zu P :gdw eval (P, o ) = eval (P, o ) für alle o O(T). 2. Ein Access-Plan P zu einer Menge von Transaktionen T heißt Endzustand-serialisierbar, wenn es einen Access-Plan P gibt, so daß gilt: (K1) (K2) P ist serieller Access-Plan, P und P sind Endzustand-äquivalent. Transaktionen: t 1 := ( 1.1 : Access A, t 2 := ( 2.1 : Access B, 1.2 : Access B ) 2.2 : Access C, 2.3 : Access A ) t 3 := ( 3.1 : Access C, 3.2 : Access A ) Plan zu T := { t 1, t 2, t 3 }: P := ( 2.1 : Access B, 1.1 : Access A, 2.2 : Access C, 2.3 : Access A, 1.2 : Access B, 3.1 : Access C, 3.2 : Access A ) O(T) = { A, B, C }; Semantik von Plan P: Access (P,A) = ( 1.1, 2.3, 3.2 ), Access (P,B) = ( 2.1, 1.2 ), Access (P,C) = ( 2.2, 3.1 ); eval (P,A) = A f 1.1 f 2.3 f 3.2, eval (P,B) = B f 2.1 f 1.2, eval (P,C) = C f 2.2 f

4 Transaktionen: t 1 := ( 1.1 : Access A, t 2 := ( 2.1 : Access B, 1.2 : Access B ) 2.2 : Access C, 2.3 : Access A ) t 3 := ( 3.1 : Access C, 3.2 : Access A ) Plan zu T := { t 1, t 2, t 3 }: P := ( 2.1 : Access B, 2.2 : Access C, 2.3 : Access A, 1.1 : Access A, 1.2 : Access B, 3.1 : Access C, 3.2 : Access A ) O(T) = { A, B, C }; Semantik von Plan P : Access (P,A) = ( 2.3, 1.1, 3.2 ), Access (P,B) = ( 2.1, 1.2 ), Access (P,C) = ( 2.2, 3.1 ); eval (P,A) = A f 2.3 f 1.1 f 3.2, eval (P,B) = B f 2.1 f 1.2, eval (P,C) = C f 2.2 f 3.1. Transaktionen: t 1 := ( 1.1 : Access A, t 2 := ( 2.1 : Access B, 1.2 : Access B ) 2.2 : Access C, 2.3 : Access A ) t 3 := ( 3.1 : Access C, 3.2 : Access A ) Pläne zu T := { t 1, t 2, t 3 }: P := ( 2.1 : Access B, P := ( 2.1 : Access B, 1.1 : Access A, 2.2 : Access C, 2.2 : Access C, 2.3 : Access A, 2.3 : Access A, 1.1 : Access A, 1.2 : Access B, 1.2 : Access B, 3.1 : Access C, 3.1 : Access C, 3.2 : Access A ) 3.2 : Access A ) Semantik von Plan P und von Plan P : Access (P,A) = (1.1, 2.3, 3.2), Access (P',A) = (2.3, 1.1, 3.2), Access (P,B) = ( 2.1, 1.2 ), Access (P',B) = ( 2.1, 1.2 ), Access (P,C) = ( 2.2, 3.1 ); Access (P',C) = ( 2.2, 3.1 ); eval (P,A) = A f 1.1 f 2.3 f 3.2, eval (P',A) = A f 2.3 f 1.1 f 3.2, eval (P,B) = B f 2.1 f 1.2, eval (P',B) = B f 2.1 f 1.2, eval (P,C) = C f 2.2 f 3.1. eval (P',C) = C f 2.2 f

5 P ist ein serieller Plan. P und P sind nicht Endzustand-äquivalent, weil eval ( P, A ) eval ( P', A ). Wir werden zeigen, daß P sogar nicht Endzustand-serialisierbar ist. Dazu konstruieren wir wie folgt einen gerichteten Serialisierbarkeitsgraphen G(P) = ( E, K ). Serialisierbarkeitsgraph G(P) = ( E, K ) zum Plan P Eckenmenge E := T, Kantenmenge K := { (t i1, t i2 ) es gibt o O(T), j1, j2 : t i1.j1 = Access o, t i2.j2 = Access o, P -1 (i1.j1) < P -1 (i2.j2), für alle z mit P -1 (i1.j1) < z < P -1 (i2.j2) ist P(z) nicht von der Form Access o } = { (t i1, t i2 ) es gibt o O(T), j1, j2 : in Access (P, o) folgt i2.j2 direkt auf i1.j1 }. Es geht also eine Kante von Transaktion t i1 nach Transaktion t i2, wenn auf die Bearbeitung eines Objekts o durch t i1 direkt die Bearbeitung durch t i2 in dem Sinne folgt, daß o zwischendurch nicht von einer anderen Transaktion bearbeitet wird

6 Serialisierbarkeits-Test Satz Sei P ein Access-Plan zu einer Menge von Transaktionen T = {t 1,..., t k } und G(P) der zugehörige Serialisierbarkeitsgraph. 1. P ist Endzustand-serialisierbar genau dann, wenn G (P) azyklisch ist. 2. Ist G(P) azyklisch und ist P ein serieller Plan, der durch topologisches Sortieren aus G(P) gewonnen wird, so sind P und P Endzustand-äquivalent. 1. und 2.: Sei G(P) azyklisch und P durch topologisches Sortieren entstanden. Für o O(T) beschreibt Access (P, o) gerade einen Pfad in G(P). Da die topologische Sortierung die Anordnung der Transaktionen entlang dieses Pfades erhält, gilt Access (P, o) = Access (P, o) und damit auch eval (P, o) = eval (P,o)

7 1. : Sei andererseits G(P) zyklisch, d.h. G(P) enthält einen Zykel (t i1,..., t ie,t i1 ). Sei P ein beliebiger serieller Plan zu T und t ia diejenige Zykeltransaktion, die in P vor allen anderen Zykeltransaktionen angeordnet ist. Sei t iv der Vorgänger von t ia im Zykel. Dann gibt es ein Objekt o und jv, ja mit t iv.jv = Access o und t ia.ja = Access o. Dann hat eval (P, o) die Form o... f iv.jv f ia.ja..., aber eval (P, o) die Form o... f ia.ja... f iv.jv..., d.h. eval (P, o) eval (P, o). Also sind P und P nicht Endzustand-äquivalent. Damit ist P nicht Endzustand-serialisierbar. Ein Serialisierbarkeitsgraph Plan: P := ( 2.1 : Access B, 1.1 : Access A, 2.2 : Access C, 2.3 : Access A, 1.2 : Access B, 3.1 : Access C, 3.2 : Access A ) Serialisierbarkeitsgraph: 1.1 : Access A / 2.3 : Access A t 1 t : Access B / 1.2 : Access B t3 Der Serialisierbarkeitsgraph ist zyklisch. 2.3 : Access A / 3.2 : Access A 2.2 : Access C / 3.1 : Access C Damit ist P nicht Endzustand-serialisierbar

8 Read/Write-Modell A1*. Im Operationsteil einer Anweisung seien nur die Operatoren Read und Write erlaubt. Die beabsichtigte Semantik von Read ist, daß die Daten aus dem im Operandenteil bezeichneten Objekt in den lokalen Speicher des die Transaktion ausführenden Prozesses gelesen werden. Die beabsichtigte Semantik von Write ist, daß die Daten des im Operandenteil bezeichneten Objekts überschrieben werden mit (möglicherweise) neuen Werten, die sich aus der Verarbeitung aller vorher gelesenen Daten ergeben können. A2. Weitere Einzelheiten der Semantik, insbesondere über die Art der Verarbeitung seien nicht bekannt. A3*. Nachdem eine Read-Anweisung ausgeführt ist, bleiben die gelesenen Daten zeitlich unbegrenzt und unverändert im lokalen Speicher verfügbar. Entsprechend liest eine Transaktion aus jedem Objekt höchstens einmal. Ferner schreibe eine Transaktion in jedes Objekt höchstens einmal (nach Abschluß aller Verarbeitungen). Wenn eine Transaktion ein Objekt sowohl liest als auch schreibt, so gehe das Lesen dem Schreiben voran. A4. Im Operandenteil von Anweisungen vorkommende Objekte seien unstrukturiert und stehen in keinerlei Beziehung zueinander. A5. Alle Transaktionen werden vollständig wirksam. A6. Alle Transaktionen liegen als unverzweigte Anweisungsfolgen textuell als Ganzes vor

9 Semantik von Read/Write-PlŠnen Der Operator Write wird derart behandelt, daß jedes Vorkommen eine verschiedene Funktion bezeichnet, diese Funktionen von geeigneter (d.h. von den vorangehenden Leseanweisungen bestimmter) Stelligkeit sind, diese Funktionen (seiteneffektfrei) ausschließlich im als Argument angegebenen Objekt eine Änderung bewirken, keine weiteren Kenntnisse über diese Funktionen vorliegen, Semantik von Read/Write-PlŠnen F ist eine Menge von Funktionszeichen. Skolem : N N 1-1 F injektive Zuordnung von (Schreib-) Anweisungen in Transaktionen, genauer von den entsprechenden Komponentennummern i.j zu Funktionszeichen. f i.j := Skolem (i,j). O(T) die Menge der in Anweisungen aus T = {t 1,...,t k } T vorkommenden Objekte. Die (Wertverlaufs-) Semantik von Plan P = ( p 1,...,p m ) ordnet jedem Objekt o O(T) und jedem Zeitpunkt z mit 0 z m einen Term über O(T) F zu vermöge folgender induktiver Vorschrift: diese Funktionen damit mit ihren unterschiedlichen Funktionszeichen identifiziert werden können. z = 0 [Initialisierung durch (Namen der) Objekte]: eval (P, o, 0) := o; Der Operator Read wird derart behandelt, daß er keine den Zustand der Objekte ändernden Seiteneffekte bewirkt. 1 z m [Seiteneffektfreie Ausführung von Anweisungen]: eval (P, o, z-1) falls p z i.j : Read x eval (P, o, z) := eval (P, o, z-1) falls p z i.j : Write x mit x o f i.j (r 1,..., r h ) falls p z i.j : Write o [bewirkte Änderung]

10 Dabei seien für den dritten Fall die Argumente r 1,...,r h wie folgt bestimmt: Die Menge z L i.j := { (o *, z * ) z * < z, und es gibt j * < j: p z * i.j * : Read o * } sei (gemäß einer linearen Ordnung auf O(T)) aufgezählt als Folge < (o 1, z 1 ),..., ( o h, z h ) >; dann sei r e := eval (P,o e, z e ) für e=1,...,h. 1 z m [Seiteneffektfreie Ausführung von Anweisungen]: eval (P, o, z-1) falls p z i.j : Read x eval (P, o, z) := eval (P, o, z-1) falls p z i.j : Write x mit x 0 f i.j (r 1,..., r h ) falls p z i.j : Write o [bewirkte Änderung] Dabei seien für den dritten Fall die Argumente r 1,...,r h wie folgt bestimmt: Die Menge z L i.j := { (o *, z * ) z * < z, und es gibt j * < j : p z * i.j * : Read o * } sei (gemäß einer linearen Ordnung auf O(T)) aufgezählt als Folge < (o 1, z 1 ),..., ( o h, z h ) >; dann sei r e := eval (P, o e, z e ) für e=1,...,h. Eine zum Zeitpunkt z ausgeführte Schreibanweisung i.j: Write o aus Transaktion i verändert den Wert des Objekts o gemäß der Verarbeitung f i.j, angewendet auf die vorher von Transaktion i zu den Zeitpunkten z 1,...,z h gelesenen Werte der Objekte o 1,...,o h

11 Transaktionen: t 1 := ( 1.1: Read A, t 3 := ( 3.1: Read C, 1.2: Write C, 3.2: Write A ) 1.3: Write B ) t 2 := ( 2.1: Read A, t 4 := ( 4.1: Read B, 2.2: Read B, 4.2: Read C, 2.3: Write D ) 4.3: Write B, 4.4: Write A ) Wertverlaufs-Semantik fÿr den Plan P P z z L i.j o A B C D 0 A B C D 2.1: Read A : Read A : Write C 3 <(A,2)>.. f 1.2 (A). 3.1: Read C : Write B 5 <(A,2)>. f 1.3 (A).. 4.1: Read B : Read C : Read B : Write A 9 <(C,4)> f 3.2 (f 1.2 (A)) : Write B 10 <(B,6), (C,7)>. f 4.3 (f 1.3 (A), f 1.2 (A)).. 2.3: Write D 11 <(A,1), (B,8)>... f 2.3 (A, f 1.3 (A)) 4.4: Write A 12 <(B,6), f 4.4 (f 1.3 (A), (C,7)> f 1.2 (A))... Endzustand: f 4.4 (f 1.3 (A), f 1.2 (A)) f 4.3 (f 1.3 (A), f 1.2 (A)) f 1.2 (A) f 2.3 (A, f 1.3 (A))

12 Wertverlaufs-Semantik fÿr den Plan PÕ P' z z L i.j o A B C D 0 A B C D 1.1: Read A : Write C 2 <(A,1)>.. f 1.2 (A). 1.3: Write B 3 <(A,1)>. f 1.3 (A).. 2.1: Read A : Read B : Write D 6 <(A,4), f 2.3 (A, (B,5)>... f 1.3 (A)) 3.1: Read C : Write A 8 <(C,7)> f 3.2 (f 1.2 (A)) : Read B : Read C : Write B 11 <(B,9), (C,10)>. f 4.3 (f 1.3 (A), f 1.2 (A)).. 4.4: Write A 12 <(B,9), f 4.4 (f 1.3 (A), (C,10)> f 1.2 (A))... Endzustand: f 4.4 (f 1.3 (A), f 1.2 (A)) f 4.3 (f 1.3 (A), f 1.2 (A)) f 1.2 (A) f 2.3 (A, f 1.3 (A)) Sicht- quivalenz von Read/Write-PlŠnen, Sicht-Serialisierbarkeit Definition 1. Seien P und P Read/Write-Pläne zu einer Menge von Transaktionen T. P ist Sicht-äquivalent zu P :gdw a. [Endzustand-äquivalent] Für den größten Zeitpunkt m von P bzw. P gilt: eval (P, o, m) = eval (P, o, m) für alle o O(T). b. [gleiche Lesesichten] Für alle Leseanweisungen i.j : Read o aus T gilt: sind z, z die Zeitpunkte mit P(z) = P (z ) = i.j : Read o, so folgt eval (P, o, z) = eval (P, o, z'). 2. Ein Read/Write-Plan P zu einer Menge von Transaktionen T heißt Sicht-serialisierbar, wenn es einen Read/Write-Plan P gibt, so daß gilt: (K1) (K2) P ist serieller Read/Write-Plan, P und P sind Sicht-äquivalent

13 initialisierend schreibende Transaktion t 0, abschlie end lesende Transaktion t f T = {t 1,...,t k } Menge von Transaktionen O(T) = {o 1,...,o e }: initialisierend schreibende Transaktion: t 0 := ( 0.1 : Write o 1,. 0.e : Write o e ), wobei die zugeordneten (nullstelligen) Funktionszeichen durch Skolem (0.j) := o j definiert seien abschließend lesende Transaktion: t f := ( f.1 : Read o 1,. f.e : Read o e ), Der erweiterte Read/Write-Plan e_p entstehe aus dem Plan P zu T durch Voranstellen von t 0 und Anhängen von t f. Polygraph G (P) = (E, K liest K vor, W) zum Read/Write-Plan P Eckenmenge E := T {t 0, t f } Kantenmenge K liest := { (t i1, t i2 ) es gibt o O(T), j1, j2: t i1.j1 = Write o, t i2.j2 = Read o, e_p -1 (i1.j1) < e_p -1 (i2.j2), und für alle z mit e_p -1 (i1.j1) < z < e_p -1 (i2.j2) ist P(z) nicht von der Form Write o } Kantenmenge K vor := { (t i2, t i3 ) t i2 liest Objekt o von t 0, t i3 T \ {t i2 }, es gibt j3: t i3.j3 = Write o } { (t i3, t i1 ) t f liest Objekt o von t i1, t i3 T \ {t i1 }, es gibt j3: t i3.j3 = Write o } Wahl-Kantenpaarmenge W := { (t i2, t i3, t i1 ) t i2 liest Objekt o von t i1, t i2 t f, t i1 t 0, t i3 T \ {t i1, t i2 }, es gibt j3 : t i3.j3 = Write o }

14 Von Transaktion t i1 geht also eine Kante nach Transaktion t i2, wenn auf das Schreiben in ein Objekt o durch t i1 direkt das Lesen aus diesem Objekt durch t i2 in dem Sinne erfolgt, daß in Objekt o zwischenzeitlich nicht durch eine andere Transaktion geschrieben wird. Eine (wegen Objekt o eingeführte) Kante (t i1, t i2 ) bedeutet also kurz: t i2 liest (Objekt o) von t i1, und entsprechend muß in dem gesuchten Sicht-äquivalenten seriellen Read/Write-Plan t i1 vor t i2 ausgeführt werden. Tatsächliche Sicht-Äquivalenz wird aber nur erreicht, wenn im gesuchten seriellen Plan nicht eine weitere in Objekt o schreibende Transaktion t i3 T sich zwischen t i1 und t i2 schiebt. Diese Überlegungen führen für die besonderen Fälle zur Kantenmenge K vor := { (t i2, t i3 ) t i2 liest Objekt o von t 0, t i3 T \ {t i2 }, es gibt j3: t i3.j3 = Write o } { (t i3, t i1 ) t f liest Objekt o von t i1, t i3 T \ {t i1 }, es gibt j3: t i3.j3 = Write o } Man beachte, daß in obiger Definition t i2 t f bzw. t i1 t 0 gelten muß. Falls in obiger Überlegung aber t i1 t 0 und t i2 t f, so drücken wir die Alternative entweder t i2 vor t i3 oder t i3 vor t i1 durch ein Wahl-Kantenpaar aus. Eine solche Transaktion muß also entweder nach t i2 oder vor t i1 ausgeführt werden. Für zwei besondere Fälle entfällt jeweils eine der Möglichkeiten: Falls t i1 die gedachte initialisierend schreibende Transaktion t 0 ist, muß t i3 also nach t i2 kommen. Falls t i2 die gedachte abschließend lesende Transaktion t f ist, muß t i3 also vor t i1 kommen

15 Kanten und Wahl-Kantenpaare Ein erweiterter Read / Write - Plan e_p (t, t ) K : i1 i2 liest (t 0, t i2 ) K liest, (t i2, t i3 ) K vor : (t i3, t i1) K vor, (t, t ) i1 f K liest : W o R ti1 ti2 W o R R t0 ti2 W o W W ti3 ti1 o o W R t i3 t f e_p = ( 0.1: Write A, 0.2: Write B, 0.3: Write C, 0.4: Write D, 2.1: Read A, 1.1: Read A, 1.2: Write C, 3.1: Read C, 1.3: Write B, 4.1: Read B, 4.2: Read C, 2.2: Read B, 3.2: Write A, 4.3: Write B, 2.3: Write D, 4.4: Write A, f.1: Read A, f.2: Read B, f.3: Read C, f.4: Read D ) A B C D (t,t ) K, (t, t, t ) W: i1 i2 liest i2 i3 i1 t i1 W W o W o R W o t i2 R t i

16 Kantenmenge K liest Kanten aus K vor und die Wahl-Kantenpaare aus W bestimmen C B,C C Für jede Kante t o i1 t i2 aus K liest jeweils alle weiteren auf o schreibenden Transaktionen betrachten: K liest K vor bzw. W A B A,B t 0 t 1 t 2 t 3 t 4 t f A D t 0 A t 2 t 2 t 2 A A t 3 t 4 t 0 A t 1 t 1 A A t 1 t 3 t 4 t 4 A t f t 3 A t 4 t 1 t 1 t 4 B B B t 4 t 2 t f t 1 B t 4 B B t2 t4 t1 t 1 t 1 t 1 C C C t 3 t 4 t f t 2 D t f

17 Serialisierbarkeitsgraph fÿr den erweiterten Read / Write - Plan e_p Serialisierbarkeits-Test Sei P ein Read/Write-Plan zu einer Menge von Transaktionen T = {t 1,...,t k } und G(P) = (E, K liest K vor, W) der zugehörige Serialisierbarkeitsgraph. t 0 t 1 t 2 t 3 t 4 t f 1. P ist Sicht-serialisierbar genau dann, wenn es eine Auswahl W * von je einer Kante aus jedem Wahl-Kantenpaar aus W gibt, so daß der entstehende Graph G * = (E, K liest K vor W * ) azyklisch ist. 2. Ist G * azyklisch und ist P ein serieller Read/Write-Plan, der durch topologisches Sortieren aus G * gewonnen wird, so sind P und P Sicht-äquivalent

18 Die Eigenschaft eines Polygraphen, eine azyklische Auswahl zu besitzen, wurde als NP-vollständig nachgewiesen. Damit ist der Begriff der Sicht-Serialisierbarkeit algorithmisch nur schwer nutzbar. Konflikt-Serialisierbarkeit liefert aber eine wieder gut handhabbare Annäherung. Test auf Azyklizität eines gerichteten Graphen kann durch ein einfaches Graphdurchlauf-Verfahren durchgeführt werden Konflikt-Serialisierbarkeit impliziert Sicht- Serialisierbarkeit Satz Sei P ein Read/Write-Plan zu einer Menge von Transaktionen T = {t 1,...,t k }. Wenn P Konflikt-serialisierbar ist, so ist P auch Sicht-serialisierbar. Beweis: Sei G konflikt (P) = (T, K konflikt ) der Konfliktgraph und G (P) = (T {t 0, t f }, K liest K vor, W) der Serialisierbarkeitsgraph zu P. Für jedes Wahl-Kantenpaar (t i2, t i3, t i1 ) ist (t i2, t i3 ) K konflikt oder (t i3, t i1 ) K konflikt. Ist dann W * eine zutreffende Auswahl, so gilt offensichtlich K liest K vor W * K konflikt. Ist nun P Konflikt-serialisierbar, so enthält K konflikt keinen Zykel, und damit enthält auch K liest K vor W * keinen Zykel. Also ist P auch Sicht-serialisierbar

19 Konflikt-Serialisierbarkeit echt strenger als Sicht-Serialisierbarkeit t 1 := ( 1.1: Read A, t 2 := ( 2.1: Write A ) 1.2: Write A ) t 3 := ( 3.1: Write A ) Projektion von PlŠnen Durch Annahme A6 vorausgesetzt, daß alle Transaktionen textuell als Ganzes vorliegen. Ein dynamisch arbeitender Scheduler verfügt aber im allgemeinen nicht über diese Kenntnis. e_p z L z o A i.j 0.1: Write A 0 A 1.1: Read A : Write A 2 < > f : Write A 3 <(A,1)> f 1.2 (A) 3.1: Write A 4 < > f 3.1 f.1: Read A 5. Der Serialisierbarkeitsgraph zeigt, daß P Sicht-serialisierbar ist: t 0 t 1 t 2 t 3 Aber der Konfliktgraph zeigt, daß P nicht Konflikt-serialisierbar ist: t f Definition Sei P ein Plan zu einer Menge von Transaktionen T. Für T T sei die Projektion π(p, T ) derjenige Plan, der aus P durch Streichen der Anweisungen aus T \ T entsteht. In diesem Fall bestehe der Definitionsbereich von π(p, T ) aus denjenigen Zeitpunkten, deren Anweisungen nicht gestrichen werden. Definition Eine Klasse κ von Plänen heißt monoton, wenn für jeden Plan P κ auch alle Projektionen π(p, T ) mit T T aus κ sind. t 1 t 2 t

20 Monotonie der Konflikt-Serialisierbarkeit Satz Die Klasse der Konflikt-serialisierbaren Pläne ist monoton. Beweis: Wenn P Konflikt-serialisierbar ist, dann ist sein Konfliktgraph G konflikt azyklisch. Da für jedes T T der Konfliktgraph G konflikt der Projektion π(p, T ) ein Untergraph von G konflikt und damit ebenfalls azyklisch ist, sind alle Projektionen wiederum Konflikt-serialisierbar. Konflikt-Serialisierbarkeit ist grš te monotone Teilklasse von Sicht-Serialisierbarkeit Satz Ein Plan P ist Konflikt-serialisierbar genau dann, wenn alle Projektionen π(p, T ) mit T T Sicht-serialisierbar sind. : Ist P Konflikt-serialisierbar, so sind wegen der Monotonie von Konflikt-Serialisierbarkeit alle Projektionen ebenfalls Konflikt-serialisierbar und damit auch Sicht-serialisierbar. : Offensichtlich gilt die folgende Hilfsbehauptung: Liegen in einem Plan eine Anweisung aus t i1 und eine Anweisung aus t i2 wegen eines Objekts o im Konflikt derart, daß keine andere Transaktion in das Objekt o schreibt, dann werden in allen seriellen, Sicht-äquivalenten Plänen t i1 und t i2 in der gleichen Reihenfolge wie die im Konflikt liegenden Anweisungen ausgeführt

21 Sei dann P nicht Konflikt-serialisierbar. Dann enthält der Konfliktgraph einen Zykel, und es sei (t 1,..., t e, t 1 ) ein Zykel kürzester Länge und T = {t 1,..., t e }. Wir werden zeigen, daß je zwei im Zykel aufeinanderfolgende Transaktionen in jedem seriellen, zu π(p, T ) Sicht-äquivalenten Plan in der Reihenfolge des Zykels ausgeführt werden müßten, d.h. einen solchen Plan kann es nicht geben. Seien also t i und t i+1 zwei im Zykel aufeinanderfolgende Transaktionen, die etwa wegen Objekt o im Konflikt liegende Anweisungen enthalten. Dann enthält der Zykel keine weitere Transaktion t j, die in o schreibt, und obige Hilfsbehauptung liefert das Gewünschte. Denn andernfalls wäre t j im Konfliktgraph mit t i und t i+1 jeweils direkt verbunden, und es läge folgende Situation vor: o t i t i+1 o... t... j Falls (t i, t j ) K konflikt oder (t j, t i+1 ) K konflikt, so wäre (t i, t j,..., t i ) bzw. (t j, t i+1,..., t j ) ein kürzerer Zykel, Widerspruch. Falls (t j, t i ) K konflikt und (t i+1, t j ) K konflikt, so ist (t i, t i+1, t j, t i ) wieder ein Zykel. Falls e > 3, so wäre dies ein kürzerer Zykel, Widerspruch. Falls e = 3, so liegt die im Konflikt liegende Anweisung aus t j entweder vor der beteiligten Anweisung aus t i oder zwischen den beteiligten Anweisungen aus t i und t i+1 oder hinter der beteiligten Anweisung aus t i+1. o In den ersten beiden Fällen wäre auch (t j, t i+1 ) K konflikt und im letzten Fall auch (t i, t j ) K konflikt, und wir hätten jeweils einen Zykel der Länge 2, Widerspruch