Objeto de Consenso Forte

Um objeto de consenso forte reforc¸a a condic¸˜ao de validade requerendo que o valor de consenso seja proposto por processos corretos mesmo na presenc¸a de processos falhos. Esta condic¸˜ao mais restrita resulta num algoritmo mais complexo (por´em, ainda simples se comparado aos trabalhos anteriores [4, 85]). Entretanto, este algoritmo n˜ao compartilha de alguns benef´ıcios do algoritmo apresentado na sec¸˜ao anterior:

• n˜ao uniforme: o algoritmo de consenso forte n˜ao ´e uniforme pois um processo participante precisa saber quais s˜ao os outros para ent˜ao ler suas propostas e decidir um valor proposto por algum processo correto;

• consenso bin´ario: nosso algoritmo resolve apenas consenso bin´ario. Esta limitac¸˜ao ´e tamb´em fruto do fato de que um processo precisa saber se um valor foi proposto por um processo correto antes de decid´ı-lo;

• objeto t-limiar: o algoritmo para consenso forte n˜ao ´e livre de espera pois s˜ao requeridas m− t propostas para garantidamente o algoritmo terminar. Entretanto, o n´umero de processos necess´arios em nosso algoritmo ´e ´otimo: m ≥ 3t + 1 (veja corol´ario 1 na pr´oxima sec¸˜ao).

Algoritmo 12 Objeto de consenso forte (processo pi).

Vari´aveis compartilhadas:

1: ts= ∅ {PEATS}

procedure x.propose(v)

2: ts.out(hPROPOSE, pi, vi)

3: S_{0← ∅} {conjunto dos processos que propuseram 0}

4: S1← ∅ {conjunto dos processos que propuseram 1}

5: while |S0| < t + 1 ∧ |S1| < t + 1 do

6: for all pj∈P \ (S0∪ S1) do

7: if ts.rdp(hPROPOSE, pj, ?vi) then

8: Sv← Sv∪ {pj} {pj propˆos v}

9: end if

10: end for

11: end while

12: if ts.cas(hDECISION, ?d, ∗i, hDECISION, v, Svi) then

13: d← v {o valor inserido ´e o valor de decis˜ao}

14: end if 15: return d

O algoritmo 12 apresenta o protocolo para consenso bin´ario forte. Este algoritmo funciona da seguinte maneira: inicialmente, um processo pi insere sua proposta no espac¸o de tuplas aumentado

tsatrav´es da inserc¸˜ao da tupla PROPOSE (linha 2). A seguir, pi acessa continuamente ts tentando

ler as propostas (linha 7) at´e que ele encontre algum valor proposto por pelo menos t + 1 processos (lac¸o das linhas 5-11). O racioc´ınio por tr´as da espera por t + 1 propostas iguais ´e que pelo menos um processo correto propˆos um valor que aparece nessa quantidade de propostas, j´a que no m´aximo

tprocessos podem falhar. O primeiro valor que satisfizer esta condic¸˜ao ´e ent˜ao inserido no espac¸o de tupla usando cas. Est´a fase de confirmac¸˜ao ´e importante porque diferentes processos podem coletar t+ 1 propostas para diferentes valores e ´e preciso garantir que uma ´unica decis˜ao seja definida. Todas as invocac¸˜oes posteriores `a operac¸˜ao cas retornaram este valor (linhas 12-14).

Object State T S

Rrdp: execute(rdp(t)) : − invoke(p, rdp(t))

Rout: execute(out(hPROPOSE, p, xi)) : −

invoke_{(p, out(hPROPOSE, p, xi)) ∧ @y : hPROPOSE, p, yi ∈ T S} Rcas: execute(cas(hDECISION, x, ∗i, hDECISION, v, Svi)) : −

invoke(p, cas(hDECISION, x, ∗i, hDECISION, v, Svi))∧

formal(x) ∧ |Sv| ≥ t + 1 ∧ (∀q ∈ Sv, hPROPOSE, q, vi ∈ T S)

Figura 6.3: Pol´ıtica de acesso para o PEATS usado no algoritmo 12.

A pol´ıtica de acesso para o PEATS usado no algoritmo 12 ´e apresentada na figura 6.3. Esta pol´ıtica especifica que qualquer processo pode ler qualquer tupla (regra Rrdp); que cada processo

pode introduzir apenas uma tupla PROPOSE no espac¸o (regra Rout); que o segundo campo do molde

usado na operac¸˜ao cas precisa ser um campo formal (regra Rcas); e que o valor de decis˜ao v deve

aparecer na propostas de pelo menos t + 1 processos. Estas regras simples, que podem facilmente ser implementadas na pr´atica, limitam efetivamente o poder de processos bizantinos, permitindo a existˆencia de um algoritmo bastante simples para a resoluc¸˜ao de consenso forte.

O algoritmo 12 requer apenas m(dlog me + 1) + (1 + (t + 1)dlog me) bits no objeto PEATS5 (m tuplas PROPOSE mais uma tupla DECISION). O algoritmo de consenso com a mesma resistˆencia apresentado em [4] requer (m + 1) 2t+1_t
sticky bits6.

Teorema 3 O algoritmo 12 implementa um objeto de consenso bin´ario forte t-limiar.

Prova: A partir da pol´ıtica de acesso podemos ver que a ´unica forma de inserir uma tupla DECISION no espac¸o ´e invocando a operac¸˜ao cas. Esta operac¸˜ao pode ser invocada com sucesso apenas uma vez, j´a que uma tupla inserida n˜ao pode ser removida (operac¸˜oes in e inp n˜ao s˜ao permitidas pela pol´ıtica), e duas tuplas de decis˜ao n˜ao podem ser inseridas (o segundo campo do molde usado na operac¸˜ao casprecisa ser formal). Em qualquer execuc¸˜ao do algoritmo, o primeiro processo que executa cas ap´os ter lido t + 1 tuplas PROPOSE com o mesmo valor v insere uma tupla DECISION com v (se sua invocac¸˜ao satisfaz a regra Rcas), fazendo com este se torne o valor de decis˜ao (linhas 13 e 15). A

propriedade de acordo ´e sempre satisfeita j´a que o valor v associado `a tupla DECISION no espac¸o ser´a lido por todos os processos corretos que n˜ao forem bem sucedidos em suas invocac¸˜oes da operac¸˜ao cas, i.e., todos que receberem false como resultado. Seus valores de decis˜ao ser´a v (linhas 12 e 15).

O algoritmo satisfaz tamb´em validade forte j´a que a tupla DECISION s´o pode ser inserida se seu valor v for justificado por t + 1 tuplas PROPOSE contendo este valor presentes no espac¸o (pelo menos uma foi inserida por um processo correto). Esta condic¸˜ao ´e reforc¸ada peloa regra Rcasda pol´ıtica de

acesso.

5_{Ex., apenas 68 bits s˜ao requeridos para t = 4 e m = 13.}

6_{O algoritmo de [4] exige uma quantidade enorme de mem´oria. Por exemplo, se queremos tolerar t = 4 processos}

Em termos de condic¸˜oes de terminac¸˜ao, o algoritmo ´e um protocolo t-limiar. Esta propriedade ´e satisfeita devido ao fato de que um processo s´o decide um valor v se este valor tiver sido proposto por t+ 1 processos. Assumindo m ≥ 3t + 1, podemos mostrar facilmente que se m − t processos corretos (pelo menos 2t + 1) invocam x.propose com algum valor v0∈ {0, 1}, sempre existir´a pelo menos t + 1 tuplas PROPOSE para algum valor (0 ou 1) e um processo ir´a inserir uma tupla de decis˜ao justificada no espac¸o. Dado que a operac¸˜ao cas ´e livre de espera, o algoritmo sempre termina.