Slide 1 Programação com Objetos Distribuídos Trabalho Leve 1 The Guardian Model and Primitives for Exception Handling in Distributed Systems Universidade

Slide 1Programação com Objetos Distribuídos Programação com Objetos Distribuídos Trabalho Leve 1Trabalho Leve 1

The Guardian Model and Primitives for Exception The Guardian Model and Primitives for Exception Handling in Distributed SystemsHandling in Distributed Systems

Universidade Federal do Rio Grande do SulInstituto de Informática

Programação com Objetos DistribuídosTrabalho Leve 1

Fernando AfonsoLeonardo Kunz


Tema Motivação e estado-da-arte Objetivos Modelo Protótipo Resultados e comparação com trabalhos relacionados Avaliação

SUMÁRIO


TEMA


TEMA

Tratamento de Excessões em Sistemas Distribuídos

• A maioria dos sistemas distribuídos requer tolerância a falhas e recuperação de erros.

• É necessário detectar falhas e executar procedimentos que retornem o sistema a um estado consistente.

• Em programas seqüenciais, “exceções” podem ser utilizadas para indicar um erro e ou uma condição anormal de execução.

• Devido a grande aceitação dos modelos de tratamento de exceções em programas seqüenciais parece lógico estendê-los para sistemas distribuídos.


Motivação e Estado da Arte


MOTIVAÇÃO EESTADO DA ARTE

• Dois tipos de técnicas de recuperação de erros:

Backward error recovery

• Consiste em restaurar o sistema para um estado anterior a falha executando um rollback.

Forward error recovery

• Consiste em corrigir ou isolar os efeitos de um erro, corrigindo assim o contexto do sistema para que as operações normais possam continuar sendo executadas.

• Em sistemas distribuídos a execução do rollback em um processo pode ocasionar o efeito dominó.

• O modelo conversation foi proposto para limitar esse efeito.



• O termination model faz com que todos processos terminem a execução de sua rotina normalmente e então cada processo chama um tratador adequado para a exceção que ocorreu.

• O modelo coordinated atomic action estende o termination model para o uso em sistemas distribuídos.

• Em Open Multi-Threaded Transactions (OMTT) um modelo é proposto para que diversas threads participem de transações aninhadas sobre objetos. Não há coordenação entre os participantes, assim as transações são abortadas no caso de uma exceção.



• Sistemas distribuídos necessitam de comunicação entre os seus tratadores de exceções.

• Múltiplas exceções podem ser chamadas em um sistema distribuído simultaneamente.

• Maioria dos sistemas de tratamento de exceções concorrentes assumem que o programa distribuído está estruturado de maneira a garantir que os tratadores de exceções corretos serão invocados sem precisarem comunicar- se.

• O guardian é um gerenciador global de exceções mais primitivo e flexível que as abordagens existentes.


Objetivos


OBJETIVOS

• Problema Fundamental:

Para o tratamento de exceções em sistemas distribuídos cada processo afetado deve invocar o tratador correto.

• Determinar o contexto e o tratador correto para cada processo em uma exceção é o problema chave.

• O objetivo do guardian é criar um tratador global de exceções que chame a exceção correta em cada processo e portanto para cada processo invoque o tratador correto.

• O tratador global de uma exceção é diferente do tratador local em cada processo.


Modelo


MODELO

• Uma entidade global distribuída (guardian) coordena o tratamento de exceções de cada processo

• Exceções apropriadas são chamadas em cada processo

• Contexto ativador – região do código que ativa exceção

• Contexto alvo – região do código onde a exceção deve ser tratada

• Regras determinam qual exceção ativar em cada participante


MODELO


MODELO

• Primitivas

void enableContext(Context c, ExceptionList el);

void removeContext();

void gthrow(GlobalException ex, ParticipantList pl);

boolean propagate();

void checkExceptionStatus();


MODELO

• Mecanismo de Regras

Geram conjunto de exceções para cada participante

Como entrada, recebe exceções sinalizadas concorrentemente

Cada exceção contém o contexto alvo para o participante


Protótipo


PROTÓTIPOExemplo: Sistema primário-backup

main() {g.enableContext(“Main”,el);try {

g.checkExceptionStatus();catch(PrimaryFailed) {

if(g.propagate()) throw;...

primaryService() {g.enableContext(“Primary”, el);try {

g.checkExceptionStatus();catch(PrimaryServiceFailed) {

g.throw(PrimaryFailed);catch(BackupFailed) {

backupAvailable = False;

// Regra 1if (signaled exception = PrimaryFailed) then {

let p = “Primary”OEL.insert(p, PrimaryFailed(“Init”)

let p = “Backup”OEL.insert(p, PrimaryFailed(“Main”)

// Regra 2if (signaled exception = BackupFailed) then {

let p = “Primary”OEL.insert(p, BackupFailed(“Primary”)

let p = “Backup”OEL.insert(p, BackupFailed(“Backup”)


Resultados e Comparação com Trabalhos Relacionados


RESULTADOS E COMPARAÇÃO COM TRABALHOS RELACIONADOS

• Vantagens

Tratamento de exceções globais é separado dos processos participantes

Mais flexível e primitivo que outras abordagens

Permite diferentes modelos de interação de aplicações distribuídas

• Desvantagens

Necessita comunicação em broadcast ordenada, confiável e temporizada

Identificação de contextos e conjunto correspondente de exceções e tratadores


Avaliação


AVALIAÇÃO

• Concluímos que é um modelo interessante pois permite separar o tratamento global de exceções do tratamento local, permitindo que cada processo chame o tratador apropriado para cada exceção.

• O artigo está bem escrito embora vá muito a fundo em detalhes técnicos e possua um pseudo-código de difícil entendimento.

• O fato de ter que definir o contexto de cada exceção dificulta a programação da aplicação.


AVALIAÇÃO

• a) Motivação e estado-da-arte: 4

• b) Problemas a resolver e Modelo: 3

• c) Protótipo, Resultados e comparação com trabalhos relacionados: 3

• d) Redação e formatação: 4

Documents

Slide 1 Programação com Objetos Distribuídos Trabalho Leve 1 The Guardian Model and Primitives for Exception Handling in Distributed Systems Universidade