Lock binario Lock binario Un lock binario pu

Lock binario

Lock binario Un lock binario può assumere solo due valori locked e unlocked Le transazioni fanno uso di due operazioni Ø lock(X) per richiedere l’accesso all’item X Ø unlock(X) per rilasciare l’item X consentendone l’accesso ad altre transazioni

Consideriamo le due transazioni T 1 read(X) X: =X-N write(X) read(Y) Y: =Y+N write(Y) T 2 read(X) X: =X+M write(X) T 2 può essere interpretata come l’accredito sul conto corrente X di una somma di denaro M T 1 può essere interpretata come il trasferimento di una somma di denaro N dal conto corrente X al conto corrente Y

Consideriamo il seguente schedule di T 1 e T 2 T 1 read(X) X: =X-N T 2 read(X) X: =X+M write(X) read(Y) write(X) Y: =Y+N write(Y) Se il valore iniziale di X è X 0 al termine dell’esecuzione dello schedule il valore di X è X 0+M invece di X 0 -N+M L’aggiornamento di X prodotto da T 1 viene perso

T 1 T 2 lock(X) read(X) X: =X-N X: =X+M write(X) unlock(X) lock(Y) read(Y) Y: =Y+N write(Y) unlock(Y)

T 1 lock(X) read(X) X: =X-N write(X) unlock(X) T 2 Schedule legale di T 1 e T 2 lock(X) read(X) X: =X+M write(X) unlock(X) lock(Y) read(Y) Y: =Y+N write(Y) unlock(Y) È risolto il problema dell’aggiornamento perso!

Modello per le transazioni Una transazione è una sequenza di operazioni di lock e unlock • ogni lock(X) implica la lettura di X • ogni unlock(X) implica la scrittura di X T 1 lock(X) unlock(X) lock(Y) unlock(Y)

Modello per le transazioni Il nuovo valore viene calcolato da una funzione che è associata in modo univoco ad ogni coppia lock-unlock ed ha per argomenti tutti gli item letti (locked) dalla transazione prima dell’operazione di unlock T 1 lock(X) unlock(X) f 1(X) lock(Y) unlock(Y) f 2(X, Y)

Equivalenza Due schedule sono equivalenti se le formule che danno i valori finali per ciascun item sono le stesse

Consideriamo le due transazioni T 1 T 2 lock(X) lock(Y) unlock(X) f 1(X) unlock(Y) f 3(Y) lock(X) unlock(Y) f 2(X, Y) unlock(X) f 4(X, Y) e lo schedule …

T 1 legge X 0 scrive f 1(X 0) T 2 lock(X) unlock(X) lock(Y) legge f 3(Y 0) scrive f 2(X 0, f 3(Y 0)) unlock(Y) scrive f 3(Y 0) lock(X) legge f 1(X 0) lock(Y) unlock(X) X 0 valore iniziale di X Y 0 valore iniziale di Y legge Y 0 scrive f 4(f 1(X 0), Y 0) valore finale di X

Consideriamo lo schedule seriale T 1, T 2 T 1 legge X 0 T 2 lock(X) scrive f 1(X 0) legge Y 0 unlock(X) lock(Y) scrive f 2(X 0, Y 0) unlock(Y) legge f 2(X 0, Y 0) unlock(Y) scrive f 3(f 2(X 0, Y 0)) lock(X) unlock(X) legge f 1(X 0) scrive f 4(f 1(X 0), f 2(X 0, Y 0)) f 4(f 1(X 0), f 2(X 0, Y 0) valore finale di X prodotto dallo schedule seriale T 1, T 2

Consideriamo lo schedule seriale T 2, T 1 T 2 lock(Y) unlock(Y) lock(X) unlock(X) legge f 4(X 0, Y 0) scrive f 1(f 4(X 0, Y 0)) legge f 3(Y 0) lock(X) unlock(X) lock(Y) scrive f 2(f 4(X 0, Y 0), f 3(Y 0)) unlock(Y) f 1(f 4(X 0, Y 0)) valore finale di X prodotto dallo schedule seriale T 2, T 1 legge Y 0 scrive f 3(Y 0) legge X 0 scrive f 4(X 0, Y 0)

T 1 lock(X) T 2 unlock(X) lock(Y) unlock(Y) lock(X) unlock(X) Pertanto lo schedule non è serializzabile in quanto produce per X un valore finale (f 4(f 1(X 0), Y 0)) diverso sia da quello (f 4(f 1(X 0), f 2(X 0, Y 0)) prodotto dallo schedule seriale T 1, T 2 sia da quello (f 1(f 4(X 0, Y 0))) prodotto dallo schedule seriale T 2, T 1

Consideriamo le due transazioni T 1 T 2 lock(X) unlock(X) f 1(X) unlock(X) f 3(X) lock(Y) unlock(Y) f 2(X, Y) unlock(Y) f 4(X, Y) e lo schedule …

T 1 legge X 0 scrive f 1(X 0) T 2 lock(X) unlock(X) legge Y 0 scrive f 2(X 0, Y 0) legge f 1(X 0) unlock(X) scrive f 3(f 1(X 0)) lock(Y) legge f 2(X 0, Y 0) lock(Y) unlock(Y) scrive f 4(f 1(X 0), f 2(X 0, Y 0))

Consideriamo lo schedule seriale T 1, T 2 T 1 legge X 0 scrive f 1(X 0) legge Y 0 scrive f 2(X 0, Y 0) T 2 lock(X) unlock(X) lock(Y) unlock(Y) lock(X) legge f 1(X 0) unlock(X) scrive f 3(f 1(X 0)) lock(Y) legge f 2(X 0, Y 0) unlock(Y) scrive f 4(f 1(X 0), f 2(X 0, Y 0))

T 1 T 2 lock(X) unlock(X) lock(Y) unlock(Y) Pertanto lo schedule è serializzabile in quanto produce sia per X che per Y gli stessi valori finali prodotti dallo schedule seriale T 1, T 2

Testare la serializzabilità Uno schedule è serializzabile se esiste uno schedule seriale tale che per ogni item l’ordine in cui le varie transazioni fanno un lock su quell’item coincide con quello dello schedule seriale

Testare la serializzabilità Algoritmo 1 Dato uno schedule S Passo 1 • crea un grafo diretto G (grafo di serializzazione) nodi: transazioni archi: Ti --> Tj (con etichetta X) se in S Ti esegue successivo unlock(X) un il Tj e lock(X)

T 1 T 2 lock(X) unlock(X) lock(Y) unlock(Y) X T 1 Y unlock(Y) lock(X) unlock(X) T 2

T 1 T 2 lock(X) unlock(X) lock(Y) unlock(Y) T 1 X, Y T 2

Testare la serializzabilità Passo 2 Se G ha un ciclo allora S non è serializzabile; altrimenti applicando a G l’ordinamento topologico si ottiene uno schedule seriale S’ equivalente ad S

Ordinamento topologico Si ottiene eliminando ricorsivamente un nodo che non ha archi entranti T 2 T 1 T 3 T 4 T 5 T 6 T 7 T 9 T 8 T 4 T 7 T 5 T 1 T 8 T 9 T 2 T 3 T 6

T 1 T 2 lock(X) unlock(X) X, Y T 1 lock(Y) unlock(Y) T 1 T 2

Teorema 1 (correttezza dell’Algoritmo 1) Uno schedule S è serializzabile se e solo se il suo grafo di serializzazione è aciclico

Protocollo di locking a due fasi Una transazione obbedisce al protocollo di locking a due fasi, o più semplicemente è a due fasi, se Ø prima effettua tutte le operazioni di lock (fase di locking) e Ø poi tutte le operazioni di unlock (fase di unlocking)

Teorema 2 Sia T un insieme di transazioni. Se ogni transazione in T è a due fasi allora ogni schedule di T è serializzabile

Dimostrazione Teorema 2 Per assurdo: ogni transazione in S è a due fasi ma nel grafo di serializzazione c’è un ciclo T 1 Xk Tk X 1 T 2 X 2 T 3 La transazione T 1 non è a due fasi (contraddizione)

Pur non essendo T 1 e T 2 a due fasi, lo schedule T 1 T 2 lock(X) unlock(X) X, Y T 1 lock(Y) unlock(Y) è serializzabile. D’altra parte… T 2

… e uno schedule delle due transazioni… Se una transazione non è a due fasi… T 1 … unlock(X) … lock(Y) … T 1 X …esiste sempre una trasazione a due fasi… T 2 lock(X) lock(Y) unlock(X) unlock(Y) T 2 Y … che non è serializzabile T 1 T 2 … unlock(X) … lock(X) lock(Y) unlock(X) unlock(Y) …

Conclusione Solo se tutte le transazioni sono a due fasi possiamo avere la certezza che ogni schedule è serializzabile