Transaes Distribudas

Ricardo Anido
MC704

Modelo de Transaes Distribudas

Transaes podem acessar dados em vrios ns.
Cada n tem um gerente local de transaes, responsvel por
Manter log para recuperao.
Coordenar a execuo concorrente das transaes
executando no n.
Cada n tem um coordenador de transaes, responsvel por
Iniciar a execuo de transaes que so originadas no n.
Distribuir subtransaes para ns apropriados.
Coordenar a terminao de transaes originadas no n, o
que resulta na transao ser validada em todos os ns ou
desfeita em todos os ns.

Arquitetura

GT3

GT1
CT1

GT2

CT3

CT2

N 3

N 1

N 2
3

Controle de Concorrncia
Protocolos baseados em locks
Protocolos baseados em timestamp

Protocolos baseados em locks

Um lock (bloqueio) um mecanismo para controle
de acessos concorrentes a um mesmo item de dados.
Dados podem ser bloqueados em dois modos:
Exclusivo (E). Dado pode ser escrito ou lido.
Compartilhado (C). Dado pode ser apenas lido.
Requisies de locks (lock-E ou lock-C) so feitas
ao gerente de controle de concorrncia. Transao
fica suspensa at que lock seja concedido.

Protocolos baseados em locks (cont.)

Matriz de compatibilidade de locks:
C
E
C Verdadeiro Falso
E Falso
Falso

Pode ser concedido um lock de um dado a uma

transao se o lock solicitado compatvel com locks
adquiridos por outras transaes para o mesmo dado.
Se o lock no pode ser concedido, a transao que
requer o lock suspensa at que todos os outros
locks incompatveis sejam liberados pelas outras
transaes.
6

Protocolos baseados em locks (cont.)

Exemplo de transao com locks:
T1:
lock-C(A)
read(A)
unlock(A);
lock-C(B)
read(B)
unlock(B)
display(A+B)

Locks usados como acima no garantem seriao: se

A e B forem atualizados entre as leituras de A e B, a
soma mostrada estaria errada.
7

Protocolos baseados em locks (cont.)

Um protocolo para locks um conjunto de regras
que todas as transaes devem seguir para requisitar
e devolver locks.
Os protocolos restringem o conjunto de
escalonamentos possveis.
Problemas que devem ser contornados:
Deadlock
No garantia de progresso (starvation, liveleness)

Deadlock
Considere o escalonamento parcial
T3

T4

lockEx(B)
read(B)
B = B 50
write(B)
lockCp(A)
read(A)
lockCp(B)
lockEx(A)

Nem T3 nem T4 podem prosseguir. Esta situao

chamada de deadlock.
Para tratar o deadlock necessrio desfazer T3 ou T4
(rollback), e liberando os locks adquiridos.
9

Falta de garantia de progresso

Considere:
Uma transao T espera por um lockEx em um
dado, enquanto uma sequncia de outras
transaes requerem e adquirem um lockCp para o
mesmo dado.
A mesma transao T desfeita repetidamente
devido a deadlock. T nunca progride.
Potencial para deadlock existe na maioria dos
protocolos baseados em locks; protocolos devem ser
projetados de forma a garantir progresso.
10

Protocolo de lock em duas fases

Garante escalonamento serivel por conflito.
Fase 1: Crescimento
Transao pode requisitar novos locks.
Transao no pode liberar locks.
Fase 2: Encolhimento
Transao pode liberar locks.
Transao no pode requisitar novos locks.

11

Protocolo de lock em duas fases (cont.)

num.
locks

fase 1

fase 2

tempo
12

Protocolo de lock em duas fases (cont.)

O protocolo garante seriao. Pode-se provar que
transaes podem ser seriadas na ordem de seus
pontos de lock (ponto onde transao adquiriu seu
ltimo lock).
O protocolo no garante inexistncia de deadlocks.
Rollbacks em cascata so possveis. Para evitar
rollback em cascata: protocolo de duas fases estrito transao deve manter locks exclusivos at validar.
Protocolo de duas fases rigoroso - todos os locks
devem ser mantidos. Transaes podem ser seriadas
na ordem em que so validadas.
13

Protocolo de lock em duas fases (cont.)

Protocolo de duas fases estrito:

num.
locks

fase 1

fase 2

libera locks compartihados

tempo
14

Protocolo de lock em duas fases (cont.)

Pode haver escalonamentos seriveis por conflito que
no podem ser obtidos quando se usa lock de duas
fases.
No entanto, na ausncia de informao extra (por
exemplo, ordem de acesso a dados), lock de duas
fases necessrio, no seguinte sentido:
Dada uma transao Ta que no obedece lock de
duas fases, podemos encontrar uma transao Tb
que usa lock de duas fases, e um escalonamento
para Ta e Tb que no serivel por conflito.
15

Converso de locks
Protocolo de lock em duas fases com converso:
Fase 1:
pode requisitar lockCp sobre dado.
pode requisitar lockEx sobre dado.
pode converter lockCp em lockEx.
Fase 2:
pode liberar lock-Cp.
pode liberar lock-Ex.
pode converter lockEx em lockCp
16

Aquisio automtica de locks

Transao T invoca as operaes padro read/write,
sem explicitar operaes de lock.
Operao read(D) processada da seguinte forma:
if (T possue lock sobre D)
read(D)
else {
se necessrio aguarda at que nenhuma outra
transao tenha um lockEx sobre D
concede lockCp sobre D a T
read(D)
}

17

Aquisio automtica de locks (cont.)

Operao write(D) processada da seguinte forma:
if (T possui lockEx sobre D)
write(D)
else {
aguarda at que nenhuma outra
transao tenha qualquer lock sobre D
if (T possui lockCp sobre D)
promove lock para lockEx sobre D
else
concede lockEx sobre D para T
write(D)
}

Todos os locks so liberados aps validao/aborto.

18

Implementao
Servidor de locks centralizado
Fcil de gerenciar, mas ponto central de falha
Servidor de locks distribudo
Resolve o problema de falha, mas pode levar a
deadlock distribudo.

19

Protocolos baseados em timestamp

Cada transao recebe uma timestamp (carimbo de
tempo) quando iniciada. Uma nova transao Ti
tem uma timestamp TS(Ti), tal que TS(Ti) > TS(Tj)
para todas as transaes Tj j existentes.
Protocolo gerencia execues concorrentes de forma
que timestamps determinam a ordem de seriao.
Mantm duas timestamps para cada dado D:
W-timestamp(D): maior timestamp de transaes que
executaram write(D) com sucesso.
R-timestamp(D): maior timestamp de transaes que
executaram read(D) com sucesso.
20

Protocolos baseados em timestamp (cont.)

Protocolo garante que quaisquer operaes
read/write conflitantes so executadas na ordem de
timestamp.
Suponha que transao T invoca read(D)
Se TS(T) < W-timestamp(D), ento T necessita ler
um valor de D que j foi escrito aps incio de T.
A operao de read rejeitada, T desfeita.
Se TS(T) W-timestamp(D), operao read
executada. R-timestamp(D) recebe o valor max(Rtimestamp(D), TS(T)).
21

Protocolos baseados em timestamp (cont.)

Suponha que transao T invoca write(D)
Se TS(T) < R-timestamp(D), ento valor que T
est produzindo foi necessrio anteriormente (e
sistema assumiu que no existiria). A operao de
write rejeitada, T desfeita.
Se TS(T) < W-timestamp(D), ento valor que T
est produzindo obsoleto. A operao de write
rejeitada, T desfeita.
Caso contrrio, a operao de write executada.
W-timestamp(D) recebe o valor TS(T).
22

Exerccio
T9: write(D)

Antes
TS-W=6
TS-R=7

Depois ?? (complete)
TS-W=
TS-R=

23

Exerccio (cont.)
T7: write(D)

Antes
TS-W=6
TS-R=8

Depois ?? (complete)
TS-W=
TS-R=

24

Exerccio (cont.)

D:
TS-W=6
TS-R=8

Qual o resultado em cada caso?

a) T7: read(D)
b) T5: read(D)
c) T9: read(D)

25

Exemplo de uso
Escalonamento parcial, transaes com timestamps
1, 2, 3, 4 e 5.
T1

T2

T3

T4

T5
read(X)

read(Y)
read(Y)
write(Y)
write(Z)
read(Z)
read(Z)
abort()
read(X)
write(Z)
abort()
write(X)
write(Z)

26

Correo do protocolo baseado em timestamp

Protocolo garante seriao, j que arestas no grafo de
precedncia so da forma:
transao com
timestamp
menor

transao com
timestamp
maior

No h ciclos no grafo de precedncia.

No h deadlock, j que transaes nunca esperam.
Escalonamento pode no ser livre de cascata, e pode
no ser recupervel.
27

Recuperao e ausncia de cascata

Problema com protocolo baseado em timestamps:
Suponha Ti aborta, mas Tj leu dado escrito por Ti.
Ento Tj deve abortar; se foi permitido que Tj
tenha sido validada, escalonamento no
recupervel.
Mais: qualquer transao que leu dado escrito por
Tj deve abortar.
Isto pode levar a uma cascata de abortos.
28

Recuperao e ausncia de cascata (cont.)

Soluo:
Estruturar transaes de forma que operaes
write so executados ao final do processamento.
Todas as operaes write formam uma ao
atmica; nenhuma transao pode executar
enquanto uma outra est em fase de escrita.
Quando uma transao aborta, ela reiniciada
com uma nova timestamp.
29

Regra escrita de Thomas

Uma modificao permite que operaes write que
so obsoletas sejam ignoradas sob certas condies:
Quando Ti tenta escrever dado D, se
TS(Ti) < W-timestamp(D),
ento Ti est escrevendo valor obsoleto. Ao invs
de abortar Ti, operao write pode ser ignorada.
Esta abordagem, conhecida como regra escrita de
Thomas (Thomas write rule) permite maior
potencial para concorrncia.
30

Mltiplas verses
Esquemas com verses mltiplas mantm verses
antigas de dados para aumentar concorrncia. Podem
ser baseados em
Ordem de timestamp
Lock de duas fases
Cada atualizao efetuada com sucesso cria uma
nova verso do dado.
Timestamps so usadas para rotular verses

31

Mltiplas verses (cont.)

Quando read(Q) executado, o sistema seleciona
uma verso apropriada de Q, com base na timestamp
da transao.
Desta forma, operaes de read nunca so
bloqueadas, sendo executadas imediatamente.

32

Verses mltiplas com timestamp

Cada dado Q tem uma sequncia de verses <Q1, Q2,
, Qn>. Cada verso Qk contm trs campos:
contedo - o valor da verso Qk.
R-timestamp(Qk) - timestamp da transao que
criou a verso Qk.
W-timestamp(Qk) - maior timestamp de uma
transao que leu a verso Qk.

33

Verses mltiplas com timestamp (cont.)

Quando transao Ti cria nova verso Qk, Rtimestamp e W-timestamp so inicializadas com
TS(Ti).
Quando uma transao Ti l Qk e TS(Ti) > Rtimestamp(Qk), atualiza-se a R-timestamp.

34

Verses mltiplas com timestamp (cont.)

Suponha que transao Ti invoque uma operao
read(Q). Seja Qk a verso de Q cuja W-timestamp
seja menor ou igual a TS(Ti).
Valor retornado o contedo da verso Qk.

35

Exerccio
Qual o valor lido?
T5

W-timestamp = 4

W-timestamp = 6

R-timestamp = 6

R-timestamp = 8

valor = 37

valor = 32

A) T5.read(Q) =
B) T7.read(Q) =

36

Verses mltiplas com timestamp (cont.)

Suponha que transao Ti invoque uma operao
write(Q). Seja Qk a verso de Q cuja W-timestamp
seja menor ou igual a TS(Ti).
Se TS(Ti) <= R-timestamp(Qk), ento Ti
abortada. Seno, se TS(Ti) = W-timestamp(Qk), o
contedo de Qk atualizado, seno uma nova
verso de Q criada.

37

Exerccio
Complete com novas verses, conforme o caso
Ti

W-timestamp = 4

W-timestamp = 6

R-timestamp = 6

R-timestamp = 8

valor = 37

valor = 32

A) T5.write(Q, 29)
B) T7.write(Q, 34)
C) T8.write(Q, 23)
D) T9.write(Q, 42)
38

Verses mltiplas com locking

Diferencia entre transaes de leitura apenas (readonly) e transaes de atualizao.
Transaes de atualizao adquirem locks de leitura
e escrita, e os mantm at o final da execuo (ou
seja, transaes seguem lock de duas fases).
Cada operao de write com sucesso resulta na
criao de uma nova verso do dado.
Cada verso do dado tem uma nica timestamp
que o valor de um contador ts_counter,
incrementado durante o processo de validao.
39

Verses mltiplas com locking (cont.)

A transaes de leitura apenas so atribudas
timestamps com o valor corrente de ts_counter antes
do incio de sua execuo.
Quando uma transao de atualizao deseja ler um
dado, deve obter um lock compartilhado. Ento, l a
verso mais recente cria uma nova verso do item
com timestamp = .

40

Verses mltiplas com locking (cont.)

Quando uma transao de atualizao Ti completa,
processo de validao faz:
Ti atribui a verses que criou a timestamp
ts_counter+1.
Ti incrementa ts_counter.
Transaes de leitura apenas que iniciam aps Ti
incrementar ts_counter acessaro valores
atualizados por Ti. As que iniciam antes do
incremento acessaro valores antes da atualizao
de Ti. Portanto, somente escalonamentos seriveis
sero produzidos.
41

Operaes de insero e remoo

Algumas transaes requerem outras operaes alm
de read e write. Vamos considerar outras duas
operaes:
delete(Q), que remove um dado.
insert(Q), que insere um dado.
Tentativa de executar read(Q) depois que Q tenha
sido removido, ou antes que tenha sido inserido,
um erro lgico.
Da mesma forma, um erro tentar remover um dado
inexistente.
42

Operaes de remoo
Se ptrotocolo de lock de duas fases utilizado,
necessrio bloquear o dado com lock exclusivo antes
que ele possa ser removido.
Se protocolo de timestamp utilizado, regra similar a
write. Suponha que Ti deseje executar delete(D):

43

Operaes de remoo (cont.)

Se TS(T) < R-timestamp(D), ento valor que Ti
iria remover foi lido por transao Tj com TS(Tj)
> TS(Ti). A operao de delete rejeitada, Ti
desfeita.
Se TS(T) < W-timestamp(D), uma transao Tj
com TS(Tj) > TS(Ti), gravou D. A operao de
delete rejeitada, Ti desfeita.
Caso contrrio, a operao de delete executada.

44

Operaes de insero
Operao insert(D) conflita com delete(D), read(D)
e write(D), j que nenhum dado pode ser removido,
lido ou escrito antes de existir.
Uma vez que insert(D) atribui um valor para o dado
D, operao deve ser tratada da mesma forma que
write, tanto no protocolo de lock como no protocolo
de timestamp.

45

Tratamento de deadlocks
Considere as seguintes transaes:
T1: write(X)
write(Y)

T2: write(Y)
write(X)

Escalonamento com deadlock:

T1

T2

lockEx(X)
write(X)
B = B 50
write(B)
lockEx(Y)
write(Y)
wait lockEx(X)
wait lockEx(Y)

46

Tratamento de deadlocks (cont.)

Sistema est em deadlock se existe um conjunto de
transaes tal que cada transao no conjunto est
esperando outra transao no conjunto.
T1

T2

T3
T4

Protocolos de preveno de deadlock garantem que

o sistema nunca entrar em deadlock.

47

Preveno de deadlocks
Algumas estratgias de preveno:
Pr-declarao: requer que cada transao efetue
lock de todos os seus dados antes do incio da
execuo.
Ordenao: Impor ordem parcial de todos os
dados e requerer que uma transao efetue lock
nos dados somente na ordem especificada.

48

Preveno de deadlocks (cont.)

Protocolos baseados em timestamp:
Esquema wait-die (no preemptivo):
Transao mais antiga pode esperar por mais
recente. Transao mais recente nunca espera por
mais antigas, so desfeitas.
Problema: transao pode morrer vrias vezes at
conseguir os dados desejados.

49

Preveno de deadlocks (cont.)

Protocolos baseados em timestamp:
Esquema wound-wait (preemptivo)
Transao mais antiga fere (fora rollback)
transaes mais recentes, ao invs de esperar.
Transaes mais recentes podem esperar por
transaes mais antigas.
Potencialmente gera menos rollback do que
esquema wait-die.
50

Preveno de deadlocks (cont.)

Tanto no esquema wait-die quanto no wound-wait,

uma transao desfeita reinicia com a mesma
timestamp original. Dessa forma, transaes antigas
tm precendncia sobre transaes recentes, o que
evita starvation.

51

Preveno de deadlocks (cont.)

Protocolo baseado em timeout:
Uma transao espera por um lock apenas durante
um perodso especificado de tempo. Depois disso, a
transao desfeita.
Vantagens: deadlocks no ocorrem, simples de
implementar.
Problemas: pode ocorrer starvation, e difcil
determinar bom valor para timeout.
52

Deteo de deadlocks
Deadlocks podem ser descritos por um grafo de
espera (wait-for graph) G = (V, E)
V o conjunto de vrtices (todas as transaes do
sistema).
E o conjunto de arestas, cada elemento um par
ordenado Ti Tj.
T1

T2

T3
T4

53

Deteo de deadlocks (cont.)

Grafo de espera:
Se Ti Tj, Ti espera que Tj libere lock de algum
dado.
Quando Ti requisita dado que Tj est utilizando,
aresta Ti Tj introduzida no grafo. Esta aresta
removida apenas quando Tj libera o lock do dado.
O sistema apresenta deadlock se e somente se existe
um ciclo no grafo de espera. Deve-se ento manter o
grafo e verificar periodicamente se apresenta ciclo.

54

Deteo de deadlocks (cont.)

Grafos de espera:
T5
T1

T2

T3

T2

T1

T3
T4

T4
Sem ciclo

T5
Com ciclo

55

Recuperao de deadlocks
Quando dedlock detectado:
Deve-se procurar uma vtima (transao que ser
desfeita). Procurar selecionar a vtima que causar
menor custo; para evitar starvation, incluir nmero
de rollbacks no custo.
Extenso do rollback:
Total: aborta a transao e a reinicia.
Parcial: efetuar rollback somente at o ponto onde
deadlock quebrado.
56