A coordenac¸˜ao generativa [60] (tamb´em chamada coordenac¸˜ao por espac¸o de tuplas) foi intro- duzida no contexto da linguagem de programac¸˜ao para sistemas paralelos LINDA[59]. O mecanismo
de coordenac¸˜ao definido nesta linguagem permite aos processos distribu´ıdos interagirem sobre um espac¸o de mem´oria compartilhado em que tuplas s˜ao adicionadas, lidas e removidas. A comunicac¸˜ao ´e chamada generativa devido ao fato de uma vez criadas no espac¸o, as tuplas tˆem existˆencia comple- tamente separada dos processos que as geraram, e podem inclusive, conter outros processos.
A figura 3.3 apresenta o modelo de coordenac¸˜ao generativa. Nesta figura os processos interagem atrav´es da inclus˜ao e remoc¸˜ao de tuplas em um espac¸o de mem´oria associativa denominado espac¸o de tuplas.
q . . . r
p
Espaço de Tuplas
out(t) rd(t) in(t)
Figura 3.3: Processos interagindo via um espac¸o de tuplas.
Uma tupla t = h f1, f2, ..., fni ´e um conjunto de campos ordenados. Cada campo fi da tupla pode
ser um atual, um formal ou o s´ımbolo especial ‘∗’. Um atual cont´em um valor de um determinado tipo. Um formal representa apenas o tipo do campo, e geralmente ´e representado por uma vari´avel deste tipo precedida por um ‘?’ (ex. ?v). O s´ımbolo especial ‘∗’ em um campo representa que tal campo pode ser qualquer vari´avel de qualquer tipo. Uma tupla em que todos os parˆametros s˜ao atuais ´e tamb´em chamada de entrada (entry). Um molde (template) ´e uma tupla que pode conter campos formais e s´ımbolos ‘∗’. Neste texto, denotamos as entradas por t e os moldes por t. O tipo de um campo, seja ele atual ou formal, ´e dado pela func¸˜ao τ :F → T , onde F ´e o conjunto de todos os poss´ıveis campos, atuais ou formais, eT ´e o conjunto dos poss´ıveis tipos de dados assumidos no modelo de computac¸˜ao usado. O tipo de uma tupla ´e definido como a seq¨uˆencia dos tipos dos campos da tupla. Em princ´ıpio, duas tuplas combinam se elas compartilham algumas caracter´ısticas como valores e tipos de campos.
As manipulac¸˜oes realizadas no espac¸o de tuplas consistem de invocac¸˜oes de trˆes operac¸˜oes b´asicas [59, 60]:
• out(t): adiciona a tupla t no espac¸o de tuplas. A operac¸˜ao out ´e chamada usualmente de operac¸˜ao de inserc¸˜ao;
• in(t): retira uma tupla que combina com o molde t do espac¸o de tuplas. Caso n˜ao exista ne- nhuma tupla que combine com t no espac¸o, o processo fica parado esperando at´e que exista uma (operac¸˜ao bloqueante). Esta operac¸˜ao ´e usualmente chamada de leitura destrutiva, remoc¸˜ao ou coleta;
• rd(t): lˆe uma tupla que combina com t no espac¸o. Caso n˜ao exista nenhuma tupla que combine com t no espac¸o o processo fica parado esperando at´e que exista uma (operac¸˜ao bloqueante). A grande diferenc¸a entre esta operac¸˜ao e a operac¸˜ao in ´e que ela n˜ao remove a tupla do espac¸o, apenas lˆe seus valores.
S˜ao tamb´em definidas duas variantes das operac¸˜oes in e rd n˜ao bloqueantes, estas operac¸˜oes s˜ao chamadas inp e rdp e seus funcionamentos s˜ao exatamente iguais as operac¸˜oes originais, a n˜ao ser pelo fato de que elas sempre retornam um valor l´ogico: se n˜ao houver uma tupla no espac¸o que combine com o molde passado, estas operac¸˜oes retornam um valor de falha false, caso contr´ario, um valor true´e retornado juntamente com a tupla lida. Note que o n˜ao bloqueio destas operac¸˜oes ´e em relac¸˜ao `a n˜ao espera pela existˆencia no espac¸o de uma tupla que combine com o molde usado. inp e rdp ainda s˜ao bloqueantes no que diz respeito ao acesso ao espac¸o de tuplas. Algumas implementac¸˜oes deste modelo (em especial a linguagem LINDA) tamb´em definem a operac¸˜ao eval(p) para a criac¸˜ao
de novos processos. A execuc¸˜ao de eval(p) cria o processo p que pode interagir atrav´es do espac¸o de tuplas [59].
As operac¸˜oes definidas para um espac¸o de tuplas s˜ao inerentemente n˜ao deterministas. Se existi- rem v´arias tuplas no espac¸o que combinam com um molde passado como parˆametro em uma operac¸˜ao inou rd, qualquer uma delas pode ser retornada. Da mesma forma, se dois ou mais processos estive- rem parados esperando por tuplas com determinadas caracter´ısticas (definidas nos moldes apresenta- dos como argumentos nas operac¸˜oes) e uma entrada ´e inserida no espac¸o de tal forma que ela combina com os moldes de qualquer um dos processos esperando a tupla, qualquer um deles pode recebˆe-la, permanecendo os demais em estado de espera.
Uma caracter´ıstica fundamental da coordenac¸˜ao generativa ´e o acesso associativo a tuplas: os dados s˜ao acessados a partir de seu conte´udo, e n˜ao atrav´es de seu enderec¸o. A id´eia ´e que o espac¸o de tuplas ´e uma sacola onde itens de dados (tuplas) s˜ao colocados, lidos e retirados de acordo com suas caracter´ısticas (conte´udo). Estes dados, uma vez no espac¸o de tuplas, n˜ao podem ser alterados. Desta forma, para se alterar uma tupla do espac¸o ´e preciso removˆe-la e criar outra tupla no espac¸o com os valores da antiga, por´em alterada. Esta caracter´ıstica de mem´oria associativa diferencia de maneira cabal este modelo de coordenac¸˜ao dos demais modelos baseados em mem´oria compartilhada. Fundamental para este mecanismo ´e o conceito de combinac¸˜ao de tuplas. Diz-se que duas tuplas, uma entrada t = h f1, f2, ..., fni e um molde t = h f1, f2, ..., f
0
mi combinam, denotado por m(t,t), se e
somente se as seguintes condic¸˜oes se verificam:
1. n = m;
A primeira condic¸˜ao verifica se o n´umero de campos do molde ´e igual ao da tupla, j´a a segunda verifica se os campos comparados das tuplas s˜ao compat´ıveis. Esta segunda condic¸˜ao usa o predicado formal(x), que ´e definido como verdadeiro se x ´e um campo formal e falso caso contr´ario.
Para fins de ilustrac¸˜ao da regra definida, considere a entrada h1, 2, “request”i. Esta tupla combina com os seguintes moldes:
• h∗, ∗, ∗i; • h1, ∗, ∗i;
• h?i, 2, ?si (i inteiro e s string); • h∗, ?i, “request”i (i inteiro).
Esta tupla, entretanto, n˜ao combina com os seguintes moldes:
• h1, ?s, ∗i (s string): tipo do segundo campo n˜ao combina;
• h?i, 2, “response”i (i inteiro): o valor do terceiro campo n˜ao combina e ele n˜ao ´e um formal; • h1, ∗, ∗, ∗i: o n´umero de campos do molde ´e maior que o da entrada.
Estes exemplos ilustram o uso da nomeac¸˜ao estruturada para restringir o espac¸o de busca em operac¸˜oes de leitura (buscando tuplas com campos contendo valores espec´ıficos) e abrir este mesmo espac¸o (gerando tuplas contendo campos formais que podem ser combinados com qualquer valor do mesmo tipo) [59].
Uma importante considerac¸˜ao a ser feita sobre o modelo de coordenac¸˜ao generativa, ´e o fato do espac¸o de tuplas ser uma mem´oria compartilhada virtual. Isto significa que ele n˜ao necessariamente precise ser implementado em uma mem´oria compartilhada ou em um n´o centralizado de uma rede de computadores, o conceito apenas imp˜oe que este espac¸o deve estar acess´ıvel aos processos que quiserem interagir atrav´es dele e que as tuplas depositadas no espac¸o estejam acess´ıveis a todos os processos interagindo atrav´es dele. As primeiras implementac¸˜oes do espac¸o de tuplas foram realiza- das em ambientes com mem´oria distribu´ıda [59, 60]. Nesta tese, apresentamos v´arios algoritmos para implementac¸˜ao do espac¸o de tuplas em um conjunto U de servidores.
3.3.1 Definic¸˜ao formal da Coordenac¸˜ao Generativa
Formalmente, o modelo de coordenac¸˜ao generativa ´e definido atrav´es da tupla hΠ, T S, Lgi. Sendo
Π o conjunto de todos os processos que podem participar de computac¸ ˜oes distribu´ıdas, T S um espac¸o de tuplas compartilhado pelos processos e Lgo conjunto de regras semˆanticas definidas na tabela 3.2.
Nesta tabela, o comportamento das operac¸˜oes ´e definido atrav´es dos valores retornados por elas e pelas alterac¸˜oes que elas causam no espac¸o de tuplas. Denotamos por T S−→op
r T S
T S∪ {t}−−→in(t) t T S, m(t,t) T S∪ {t} rd(t) −−→ t T S∪ {t}, m(t,t) T S∪ {t}−−−→inp(t) true,t T S, m(t,t) T S∪ {t} rdp(t) −−−→ true,t T S∪ {t}, m(t,t) T S−−−→inp(t) false T S, @t ∈ T S : m(t,t) T S rdp(t) −−−→ false T S, @t ∈ T S : m(t,t) T S−−−→out(t) − T S∪ {t}
Tabela 3.2: Semˆantica das operac¸˜oes em um espac¸o de tuplas (Lg).
opsobre o espac¸o de tuplas T S retornando para a entidade executora o valor r e colocando o espac¸o no estado T S0. A tabela mostra o resultado das 5 operac¸˜oes [59] definidas originalmente na coordenac¸˜ao generativa. As duas primeiras regras mostram o resultado das operac¸˜oes in(t) e rd(t) quando m(t,t), sendo t uma tupla presente no espac¸o de tuplas. Note que t ´e removida do reposit´orio na operac¸˜ao in(t). As duas regras seguintes mostram o resultado das variantes n˜ao bloqueantes destas operac¸˜oes quando estas s˜ao bem sucedidas. Note que elas s˜ao iguais a n˜ao ser pelo valor true retornado junto com a tupla. O resultado das operac¸˜oes n˜ao bloqueantes quando n˜ao existe tupla nenhuma no espac¸o que combina com t ´e definido nas duas regras seguintes. Finalmente a operac¸˜ao out(t) ser definida como a adic¸˜ao de t ao conjunto de tuplas no espac¸o T S.
3.3.2 Espac¸o de Tuplas Aumentado
Em [117] ´e provado que o espac¸o de tuplas ´e um tipo de objeto de mem´oria compartilhada com n´umero de consenso igual a 2, na hierarquia livre de espera definida por Herlihy [67]. Isto significa que ele pode ser usado para resolver consenso entre dois processos em sistemas ass´ıncronos mesmo na presenc¸a de falhas [67]. Nesta tese queremos resolver consenso e apresentar construc¸˜oes universais para um n´umero arbitr´ario de processos, assim, precisamos de objetos de mem´oria compartilhada universais (com n´umero de consenso n, em um sistema com n processos) [9, 67]. Conseq¨uentemente, usamos um espac¸o de tuplas aumentado [11, 117] que suporta uma operac¸˜ao extra de inserc¸˜ao condicional atˆomica (Conditional Atomic Swap - CAS). Esta operac¸˜ao, denotada por cas(t,t) para um molde t e uma entrada t, funciona como uma execuc¸˜ao atˆomica (indivis´ıvel) da seguinte instruc¸˜ao:
if ¬rdp(t) then out(t)
O significado desta instruc¸˜ao ´e “se a leitura de t falhar, insira a entrada t no espac¸o”2. Esta operac¸˜ao retorna true se a tupla ´e inserida no espac¸o e false caso contr´ario. O espac¸o de tuplas aumentado ´e um objeto de mem´oria compartilhada universal, j´a que pode ser usado para resolver consenso livre de espera de forma trivial tanto no modelo de faltas por parada [11, 117] quanto com faltas bizantinas (como ser´a visto no cap´ıtulo 6) para um n´umero qualquer de processos.
A adic¸˜ao dessa operac¸˜ao implica na adic¸˜ao das regras definidas na tabela 3.3 `aquelas apresentadas na tabela 3.2.
2Note que o significado da operac¸˜ao cas do espac¸o de tuplas ´e o oposto da conhecida operac¸˜ao compare&swap para
T S∪ {t} cas(t,t 0) −−−−→ false,t T S∪ {t}, m(t,t) T S cas(t,t0) −−−−→ true T S∪ {t 0}, @t ∈ T S : m(t,t)
Tabela 3.3: Semˆantica da operac¸˜ao cas.