Neste algoritmo, um nodo sem-falha executa testes em sequência, até que encontre um outro nodo sem-falha, para então obter as informações de diagnóstico sobre os outros nodos presentes no sistema (exceto os nodos que já testou anteriormente).

Os nodos presentes no sistema podem ser representados por um grafo completo e os nodos sem-falhas foram um anel no grafo, conforme exibido na figura 1.

• -1 significa que estado do nodo é desconhecido (UNKNOWN)
• 0 - significa que o nodo está sem-falha
• 1 - significa que o nodo está falho

O trabalho foi dividido em 4 pequenas tarefas, implementadas a partir do código base passado pelo professor em sala de aula.

A tarefa 1 consistia em fazer com que cada nodo testasse o próximo no anel. Esta etapa foi feita em laboratório com o professor, e foi facilmente implementada com o acréscimo de uma estrutura condicional (IF/ELSE) quando a simulação faz um teste em um nodo. O próximo nodo é definido como:

(token+1)%N

Onde token indica qual nodo está sendo executado pelo sistema no momento, e N representa o número de nodos do sistema.

O teste é feito através da função do smpl status.

A tarefa 2 consistia em fazer com que cada nodo sem-falha executasse testes sequencialmente, até que fosse encontrado um outro nodo sem-falha. Isto foi implementado com a ajuda de uma estrutura de repetição (FOR), sendo que toda vez que o nodo atual (token) encontrar um outro nodo falho, então continua a andar no grafo procurando um nodo sem-falha. Quando este é encontrado, o FOR é quebrado.

Na tarefa 3 foi criado um vetor chamado STATE dentro da estrutura do nodo, de forma que cada nodo tenha um vetor STATE para armazenar a informação do nodo testado (0 - fault-free e 1 - faulty).

Estas informações são salvas dentro do IF já existente no código, onde é feito o teste através da função status e então o retorno é utilizado como informação para atualizar o vetor STATE do nodo.

A tarefa 4 permite que um nodo sem-falha, ao encontrar outro nodo sem-falha, obtenha as informações de diagnóstico daquele nodo, sabendo assim os estados de nodos que não foram testados por ele. Para cumprir esta tarefa foi apenas criado um FOR para efetuar a cópia do vetor STATE, dentro da condição do IF de quando o nodo encontra um outro nodo sem-falha.

Com isso, o algoritmo Adaptive DSD está implementado.

* Informação importante sobre os logs obtidos

De acordo com a teoria vista em sala de aula do Adaptive DSD, a latência é definida como o número de rodadas de testes necessárias para completas o diagnóstico de um evento no pior caso.

Uma rodada de testes, por sua vez, é definida como o intervalo no qual todos os nodos sem-falhas do sistema completaram seus testes, ou seja, quando o anel completa uma volta. A latência do Adaptive DSD é N. Por exemplo, em um sistema com 5 nodos, onde 4 estão falhos, são necessárias 5 rodadas de teste para completar o diagnóstico. No melhor caso, sem nenhum nodo falho, é necessária apenas 1 rodada de testes para completar o diagnóstico.

Para a elaboração deste trabalho, NÃO foi criada uma condição que identifica o fim de um diagnóstico e interrompe a simulação. A condição em questão fica de certa forma até fora de questão, se considerarmos sistemas de grande escala, onde são possíveis milhares de nodos, pois a execução do diagnóstico demoraria muito para ser encerrada. Além disto, não há como garantir, em um sisema real, que um nodo nunca mais irá falhar, ou recuperar. Durante a elaboração deste trabalho, a simulação tem um tempo pré-determinado para executar e este tempo nunca é interrompido, a não ser por algum erro. Esta situação traz a tona duas características a serem observadas durante a análise dos resultados deste trabalho:

1. O tempo de execução definido limita o número de nodos que serão testados. Isso implica que, se por exemplo, forem definidas 130 unidades de tempo para a simulação durar, e 10 nodos no sistema, haverão nodos que não terão tempo para serem testados. Isto também é influenciado pelo intervalo de tempo em que os testes são executados. Esse comportamento é observado através dos valores do vetor STATE. Quando o tempo for muito pequeno para a quantidade de nodos, haverão nodos que permanecerão com o valor -1 até o final da execução.
2. Também pelo fato de haver um tempo pré-determinado para a execução durar e não haver critério de parada para quando o diagnóstico está completo, o número de rodadas de testes observados a partir dos logs gerados, serão DIFERENTES das vistas em teoria. Para os programas com nodos sem-falha, o número de rodadas de testes será o mesmo número de nodos que conseguem ser testados durante o tempo definido. Por exemplo, se são colocados 10 nodos sem-falha para executar em 130 segundos, apenas alguns terão tempo de ser executados e o número de rodadas de teste será este mesmo valor. Isso ocorre porque, mesmo que em apenas 1 rodada de teste o diagnóstico esteja completo, o programa não sabe disso e não interrompe a simulação, então continua prosseguindo com as rodadas de teste enquanto o tempo permitir. Como é o 'melhor caso', dará tempo de executar um número r de rodadas, sendo os mesmos r números de nodos que tiveram tempo para serem testados. Já nos casos em que há nodos falhos e são necessários mais testes dentro de uma mesma rodada de testes, o tempo será gasto com estes testes, muitas vezes não permitindo que sejam completadas as r rodadas de teste, será sempre um número menor.