Tcc Biocluster java

1. Jean Rodrigo dos Santos
Rafael Caetano Pinto
Valdemárcio Fernandes dos Santos
BioCluster
Comparação de Seqüências de DNA em Sistemas
Distribuídos Clusterizados
Osasco
Dezembro de 2005

2. Jean Rodrigo dos Santos
Rafael Caetano Pinto
Valdemárcio Fernandes dos Santos
BioCluster
Comparação de Seqüências de DNA em Sistemas
Distribuídos Clusterizados
Trabalho de Conclusão de Curso para o
curso de Engenharia de Computação do
Centro Universitário FIEO como requisito
parcial para a obtenção do título de bacharel
em Engenharia de Computação.
Orientadores:
Prof. Antonio Fernando Nunes Guardado
Prof. Francisco Isidro Massetto
Osasco
Dezembro de 2005
2

3. Persevera na tua determinação.
3

4. Agradecemos às pessoas abaixo que
contribuíram para a conclusão desse projeto:
Antonio Fernando Nunes Guardado,
Celso Silva,
Gabriela M. de Azevedo Souza,
Jean M. Laine,
Jonas Santiago de Oliveira,
Maisa Barros de Oliveira,
Maria Clara de Carvalho Silva,
Martin R. Whittle,
Paulo Cunha,
Pedro Rosa,
Sidney da Silva Viana.
Em especial, agradecemos a Francisco
Isidro Massetto, pois sem sua ajuda e boa
vontade, esse projeto não seria possível.
iv
4

5. Resumo
Esse projeto visa a construção e a configuração de um Sistema Distribuído
aplicado para a comparação de seqüências de DNA. Será mostrada neste trabalho toda a
especificação necessária para a construção e implementação do mesmo.
Um dos objetivos principais abordados nesse trabalho é a preocupação na
elaboração de uma solução menos custosa financeiramente em relação aos Sistemas
Centralizados Proprietários sem que haja uma queda significativa no desempenho da
aplicação.
Para se alcançar esse objetivo, será utilizada uma estrutura de rede
FastEthernet e alguns micro-computadores interconectados sobre o protocolo TPC/IP.
Como exemplo para a implementação deste sistema clusterizado, foi escolhido o
algoritmo CGM/BSP de similaridade de seqüências, devido ao fato de que nessa
aplicação, dependendo do conjunto de dados a se comparar, é necessário um alto poder
computacional para se realizar a comparação entre seqüências.
Palavras-chave: Cluster. DNA. RMI. Sistemas Distribuídos.
v
5

6. Abstract
This project aims the construction and the configuration of a Distributed
System suitable for a DNA sequences comparation. All specifications needed for its
construction and implementation will be shown at this project.
One of the main subjects approached at this work is the concern about a
cheaper solution elaboration in relation to an Owner Centralized Systems without a deep
fall on the application s performance.
A basic net structure with one switch and a few personal computers
interconnected using the TPC/IP protocol will be created to reach the subject of this
project. As an example for the clustered system implementation, a comparative between
DNA s has been chosen, due to the needed of a high computational power, in order to
carry this comparison out between sequences, although it can depend on the data group
to be compared.
Keywords: Cluster. DNA. RMI. Distributed Systems.
vi
6

7. Sumário
v
Resumo ................................................................................................................................. 5
vi
Abstract ................................................................................................................................. 6
Sumário ................................................................................................................................. 7
Capítulo 1 ............................................................................................................................ 10
Objetivos.......................................................................................................................... 11
Justificativa ...................................................................................................................... 12
Metodologia ..................................................................................................................... 13
Capítulo 2 ............................................................................................................................ 14
Introdução a Sistemas Distribuídos................................................................................. 15
Comparação dos Sistemas Distribuídos com os Sistemas Centralizados.................. 15
Mudança de paradigma de programação ................................................................ 17
Modelo Cliente-Servidor .............................................................................................. 17
Simplicidade ............................................................................................................. 18
Baixa taxa de overhead na rede .............................................................................. 18
Níveis de protocolos................................................................................................. 18
Bloqueadas ou não-bloqueadas .............................................................................. 18
Bufferizadas e não-bufferizadas .............................................................................. 19
Confiáveis e não-confiáveis ..................................................................................... 19
Clusters............................................................................................................................ 19
Características de um Cluster ..................................................................................... 19
Alto desempenho ..................................................................................................... 19
Escalabilidade .......................................................................................................... 20
Confiabilidade e tolerância à falha ........................................................................... 20
Alta disponibilidade .................................................................................................. 20
Independência.......................................................................................................... 20
Transparência .......................................................................................................... 21
Comunicação entre processos no Cluster................................................................... 22
Cluster Homogêneo e Heterogêneo ............................................................................ 23
Tipos de Cluster........................................................................................................... 24
Cluster de Alto Desempenho ................................................................................... 24
Clusters de Alta Disponibilidade .............................................................................. 24
Clusters de Balanceamento de Cargas ................................................................... 24
Exemplos de Clusters .............................................................................................. 24
Cluster Beowulf..................................................................................................... 24
Invocação Remota de Métodos (RMI) ......................................................................... 27
RMI-Registry.................................................................................................................... 28
Exemplo de programa em RMI ................................................................................ 28
Ola.java (interface) ............................................................................................... 28
OlaImpl.java (implementação do servidor)........................................................... 29
OlaCliente.java (cliente) ....................................................................................... 29
Sistema de Arquivo de Rede (NFS Network File System) ....................................... 30
Capítulo 3 ............................................................................................................................ 31
Biologia Computacional................................................................................................... 32
Conceitos de Biologia .................................................................................................. 32
Comparação de seqüências e Alinhamento................................................................ 33
Uma breve explicação de como foi montada a matriz............................................. 36
7

8. Algoritmo para validação de sequências de DNA ....................................................... 38
Similaridade distribuída (CGM/BSP) ........................................................................... 38
Algoritmos de alinhamento e similaridade utilizados como base neste projeto.............. 40
Algoritmo básico do método alignment() da classe DNA ............................................ 40
Algoritmo básico do método similarity() da classe DNA.............................................. 41
Algoritmo básico do método CGM/BSP() da classe DNA ........................................... 42
Capítulo 4 ............................................................................................................................ 43
Especificações do projeto................................................................................................ 44
Conceitualização do projeto ........................................................................................ 44
Modularização e divisão de responsabilidades ........................................................... 44
Módulo Interface Web .............................................................................................. 45
Módulo Gerenciador................................................................................................. 45
Módulo Executor ...................................................................................................... 45
Estratégia de Comparação CGM/BSP utilizando RMI ......................................... 46
Módulo ClusterKnoppix ............................................................................................ 48
Especificações do sistema........................................................................................... 49
Rede ......................................................................................................................... 49
Características dos nós do sistema ......................................................................... 49
Armazenamento dos dados ..................................................................................... 49
Sistema Operacional ................................................................................................ 50
Linguagem de programação .................................................................................... 50
Pacote para aplicação de computação distribuída .................................................. 50
Características do Cluster ........................................................................................ 50
Tratamento de erros................................................................................................. 52
Testes....................................................................................................................... 52
Casos de Uso .................................................................................................................. 54
Caso de Uso Nv0 Sistema distribuído clusterizado para comparação de seqüências
de DNA......................................................................................................................... 55
Caso de Uso Nv1 Funcionalidades Gerais............................................................... 56
Caso de Uso Nv2a - Comparar Seqüências de DNA.................................................. 57
Caso de Uso Nv2b - Inserir nova máquina no sistema ............................................... 59
Caso de Uso Nv2c - Inserir seqüência de DNA no banco de dados .......................... 60
Caso de Uso Nv2d - Remover seqüência de DNA do banco de dados...................... 61
Caso de Uso Nv2e Inicializar sistema distribuído .................................................... 62
Diagrama de Classes ...................................................................................................... 63
Parte 1.......................................................................................................................... 63
Parte 2.......................................................................................................................... 64
Diagramas de Seqüência ................................................................................................ 65
Inicialização do Executor ............................................................................................. 65
Inicialização do Gerenciador ....................................................................................... 66
Comparando DNA: Visão do módulo ClusterInterface................................................ 67
Comparando DNA: Visão do módulo Gerenciador ......................................................... 68
Comparando DNA: Visão do módulo Executor: Primeiro Executor ................................ 69
Comparando DNA: Visão do módulo Executor: Executores centrais............................. 70
Comparando DNA: Visão do módulo Executor: Último Executor ................................... 71
Diagramas de Transição de Estado ................................................................................ 72
Executor ....................................................................................................................... 72
Gerenciador ................................................................................................................. 72
Diagramas de Atividade .................................................................................................. 73
Método Similarity ......................................................................................................... 73
Método CGM/BSP ....................................................................................................... 74
Banco de dados............................................................................................................... 75
Diagrama Entidade Relacionamento ........................................................................... 75
8

9. Domínios .................................................................................................................. 75
Modelo do Banco de dados ......................................................................................... 75
Dicionário de dados ..................................................................................................... 75
tbldna........................................................................................................................ 75
tblrelaction ................................................................................................................ 76
Script de criação de tabelas ........................................................................................ 76
Tabela tblDNA .......................................................................................................... 76
Tabela tblRelaction................................................................................................... 76
Arquivo de configuração do MySQL ............................................................................ 76
Interface do Sistema........................................................................................................ 79
Arquitetura da interface:............................................................................................... 79
Interface Web............................................................................................................... 79
Estrutura de comunicação da interface Web............................................................... 80
Evento na página "Tela Principal": Entrada ............................................................. 80
Evento na página "Tela Principal": Clique em Comparar ........................................ 80
Evento na página "Relacionamento": Clique em Pesquisar .................................... 80
Evento na página "Relacionamento": Clique em Relacionar................................... 80
Capítulo 5 ............................................................................................................................ 81
Caracteristicas do Ambiente............................................................................................ 82
Configurações fisicas:.................................................................................................. 82
Máquinas: ................................................................................................................. 82
Rede: ........................................................................................................................ 82
Configurações lógicas:................................................................................................. 82
Máquina Gerenciadora:............................................................................................ 82
Máquina do Repositório de dados: .......................................................................... 82
Máquinas Executoras:.............................................................................................. 82
Metodologia.................................................................................................................. 83
Conclusão ........................................................................................................................... 89
Recomendações para projetos futuros ............................................................................... 90
Referências ......................................................................................................................... 91
Anexo A Implementação do ClusterKnoppix ................................................................... 93
Planejamento................................................................................................................... 93
Instalação ........................................................................................................................ 94
BOOT Remoto ................................................................................................................. 95
Aplicação ....................................................................................................................... 101
Resultados..................................................................................................................... 102
Customização ................................................................................................................ 103
9

10. Capítulo 1
Esse capítulo preza a contextualização do
projeto, nele serão definidos a
justificativa, os objetivos e a metodologia
utilizada no desenvolvimento deste
trabalho.
10

11. Objetivos
Elaborar o projeto de um Sistema Distribuído Clusterizado utilizando
algoritmos paralelizáveis existentes para uma aplicação específica e assim, testar o
funcionamento desta plataforma distribuída.
Utilizaremos como aplicação o sequenciamento físico de DNA devido a suas
características escaláveis e paralelizáveis. Dessa forma poderemos analisar o
comportamento do Sistema Distribuído em uma aplicação mediante alterações de
configuração com a finalidade de otimizar o processamento como um todo. Obtendo
assim, um desempenho no mínimo satisfatório (um desempenho semelhante ao de um
sistema centralizado em uma máquina mono-processada com as mesmas características
das máquinas utilizadas no cluster).
Os principais objetivos a serem alcançados no projeto são:
Escalabilidade Incluir ou retirar máquinas do sistema facilmente de forma a
manter o sistema escalável conforme a necessidade de desempenho da aplicação;
Custo Objetiva-se utilizar microcomputadores padrão IBM - PC e uma rede LAN
Fast Ethernet TCP/IP por serem mais acessíveis economicamente. Também é
decisão de projeto a utilização de uma linguagem multiplataforma (Java) de modo
que se obtenha mais versatilidade, minimizando as limitações ocasionadas pelo
uso de sistemas operacionais proprietários que geralmente possuem custo
elevado.
Acessibilidade Será desenvolvido um sistema de código aberto que seja
economicamente viável em comparação às tecnologias centralizadas proprietárias.
Desempenho Em um primeiro estágio do projeto, o objetivo é de se projetar um
sistema clusterizado com desempenho comparável ao de um sistema centralizado
mono-processado. Atingido esse objetivo primário, serão verificadas novas
alternativas de projeto para melhorar o desempenho do sistema.
11

12. Justificativa
Em função do crescente desenvolvimento de Sistemas Distribuídos,
impulsionado pela demanda de alto poder computacional, explorar seus recursos torna-se
cada vez mais imprescindível [ERA04]. Com base nesta afirmação, e pelo objetivo de
obter um sistema de baixo custo financeiro, este projeto se destina à construção de um
cluster para executar tarefas que requeiram um alto poder computacional.
Um cluster é um sistema de processamento paralelo alternativo, que
apresenta um desempenho computacional análogo aos sistemas centralizados. Uso de
clusters nas soluções de determinados projetos, tais como processamento de imagens ou
de massas de dados, torna-se economicamente mais viável que em sistemas
centralizados, mantendo um desempenho igual ou superior dependendo da
implementação.
Neste projeto, será implementado e testado o algoritmo CGM/BSP, que é uma
versão paralela para um algoritmo que compara graus de similaridade entre seqüências
de genes. Para uma maior compreensão sobre o assunto, primeiramente será
apresentada uma introdução aos conceitos básicos de sistemas distribuídos e clusters,
assim como uma breve abordagem dos conceitos da biologia e das aplicações da
computação na área biológica, inclusive com os algoritmos para sequenciamento e
comparação de DNA, assim como o algoritmo CGM/BSP, que é a base deste trabalho.
Todas as etapas de evolução do projeto, tais como contextualização,
especificações, modelagens, desenvolvimento e fase de testes serão documentadas. Há
a preocupação inclusive em documentar alguns tratamentos de falhas que podem ser
interessantes para desenvolvimentos futuros.
12

13. Metodologia
Como metodologia abordada, será adotado basicamente o Modelo em Espiral,
também denominado por vários autores como Modelo Evolutivo, em que a cada etapa
concluída repete-se o processo de averiguação por meio de protótipos para o
aperfeiçoamento do projeto.
Para a documentação, será adotado o conceito de Orientação a Objetos, que
melhor atende aos requisitos do projeto uma vez que será utilizada uma linguagem
orientada a objeto (Java). Portanto, utilizar-se-á dos padrões da linguagem UML.
13

14. Capítulo 2
Esse capítulo objetiva apresentar a
introdução conceitual sobre sistemas
distribuídos, modelos de comunicação,
clusters e suas aplicações.
14

15. Introdução a Sistemas Distribuídos
Neste projeto, a definição de sistema distribuído será uma combinação de
ambas as definições, ou seja, um sistema distribuído é um agrupamento de computadores
que se apresenta ao usuário como um sistema único, compartilhando recursos. Desta
forma, o Sistema Distribuído apresenta muitas diferenças em relação a um sistema
centralizado.
Desde 1945 quando se iniciou a era da computação moderna, os
computadores têm sofrido grandes transformações tecnológicas [TAN95]. Durante o
período de 1945 a 1980, a necessidade de compartilhar informações era praticamente
nula e devido ao pequeno número de computadores nas organizações, as quais muitas
faziam uso somente de um computador, quase sempre mainframes.
A necessidade de comunicação foi se intensificando a medida que os
computadores foram se tornando mais acessíveis financeiramente, passando a aparecer
no cenário empresarial (comercial/industrial) tornando-se umas das principais ferramentas
da indústria. Para sanar a deficiência da comunicação, foram desenvolvidas nos anos 80,
as redes locais de alta velocidade (LAN). Tais tipos de redes em conjunto com os avanços
tecnológicos dos microcomputadores, culminaram no desenvolvimento dos sistemas
distribuídos.
Diferentes autores definem de maneira distinta o conceito de sistema
distribuído. Segundo Tanembaum [TAN95], Sistemas Distribuídos são definidos como
uma coleção de computadores independentes que se apresentam ao usuário como um
sistema único e consistente . Já Couloris [COU01] define sistema distribuído como sendo
uma coleção de computadores autônomos interligados através de uma rede de
computadores e equipados com software que permita o compartilhamento dos recursos
dos sistemas: hardware, software e dados .
Neste projeto, a definição de sistema distribuído será uma combinação de
ambas as definições, ou seja, um sistema distribuído é um agrupamento de computadores
que se apresenta ao usuário como um sistema único, compartilhando recursos. Desta
forma, o Sistema Distribuído apresenta muitas diferenças em relação a um sistema
centralizado.
Comparação dos Sistemas Distribuídos com os Sistemas Centralizados
Atualmente instituições acadêmicas e industriais de modo geral, vêm
desenvolvendo aplicações que exigem cada vez mais um alto poder computacional.
Entretanto o custo para adquirir tais máquinas com essa característica é extremamente
alto em muitos casos proibitivos, fazendo com que essas organizações migrem para
outras alternativas.
Uma saída encontrada por especialistas para esse problema foi uma
arquitetura de "Sistema Distribuído", que consiste em um aglomerado de
microcomputadores mono ou multiprocessados e que executam uma tarefa como se
fosse um único sistema.
Enquanto que em um Sistema Centralizado, uma aplicação é executada por
um ou vários processadores localizados em um mesmo computador, um Sistema
distribuído conte com um certo número de nós (computadores conectado em uma rede
15

16. comum) onde cada um deles executa uma aplicação ou parte dela.
Em um Sistema Centralizado existem limitações que torna os Sistema
distribuídos potencialmente superiores em poder computacional. Por exemplo, um
Sistema Centralizado é limitado em espaço físico não podendo comportar muitos
processadores numa mesma placa mãe, enquanto que a escalabilidade de um Sistema
distribuído o permite a superar a quantidade de processadores em um Sistema
Centralizado.
Outra vantagem é o uso da memória (principal) em um Sistema Centralizado
multiprocessado, pois as tarefas precisam entrar em uma fila para o uso da memória
principal, ao passo que nos Sistemas Distribuídos, cada nó conta com a sua própria
memória para uso independente das aplicações.
Entre as vantagens de um Sistema Distribuído em relação a um Sistema
Centralizado pode-se citar [Tanenbaum]:
- Custo: o valor financeiro para implementação de um Sistema distribuído é
geralmente muito inferior ao valor de um Sistema Centralizado com um poder
computacional equivalente, e utilizando um sistema Open Source e linguagem de
programação Java, por ser livre e gratuito, no que diz respeito a Softwares, não existe
despesas com Licenças;
- Desempenho: Sistema com altíssimo índice de processamento, tais como o
Blue Gene (www.top500.org) são capazes de processar 280600 Gflops (consultada em
13/12/2005), tal capacidade atualmente só é possível em plataformas distribuídas;
- Tolerância a Falhas: Um Sistema distribuído pode contar com algoritmos
que detectam a falha em um nó e redirecione as tarefas a serem executadas para outro
nó. Dessa forma a capacidade de índices de confiabilidade de um Sistema distribuído é
superior a um Sistema Centralizado;
- Flexibilidade: os recursos oferecidos por um nó podem ser migrados para
outros nós, mantendo assim uma redundância dos recursos e maior disponibilidade dos
serviços;
- Escalabilidade: é a característica de um Sistema distribuído tem de acoplar
mais computadores à sua rede mantendo a estabilidade e aumentando a eficácia do
Sistema.
Entretanto, há desvantagens, que alguns autores consideram desafios, tais
como:
- Transparência: um dos objetivos é manter oculto os aspectos distribuídos
dos usuários do Sistema. O acesso a arquivos distribuídos por diversos computadores
remotos não deve ser diferente a um acesso a arquivos locais. Um usuário deve poder
acessar arquivos do Sistema sem precisar saber de sua localização ou comunicação
entre processos;
- Segurança: é muito difícil estabelecer um protocolo de segurança eficiente
para Sistemas Distribuídos, pois todos os nós possuem acessos entre eles, então
algoritmos de segurança para garantir a integridade dos dados devem ser implementados;
- Viabilidade: nem todos as aplicações que executam de maneira eficiente
16

17. em um Sistema Centralizado irão executar na mesma maneira em um Sistema distribuído.
Deve-se verificar se os algoritmos das aplicações são paralelizáveis, pois um Sistema
distribuído só é viável se suas aplicações permitirem que sejam fragmentadas e
distribuídas entre os nós.
Para esse projeto, a viabilidade do uso de um Sistema distribuído ao invés de
um Sistema Centralizado se dá através das vantagens já apresentadas neste capítulo.
Justificamos o uso pelo propósito da pretensão de utilizar um sistema robusto para
manipular uma grande quantidade de dados e que apresente um baixo custo financeiro
em relação aos sistemas mono-processados. Assim, utilizando técnicas de fragmentação
de dados e paralelização da aplicação, uma implementação distribuída tende a obter
resposta satisfatórias para o nosso intento.
Mudança de paradigma de programação
Uma das dificuldades que envolve a implementação de um Sistema
Distribuído é o paradigma da programação distribuída. Programação distribuída prevê as
chamadas de métodos localizados em máquinas diferentes através da troca de
mensagens e sincronização.
As trocas de mensagens são realizadas através de algoritmos que fazem uso
de primitivas como send e receive, essas primitivas podem ser organizadas de forma
síncronas ou assíncronas. O que difere uma da outra é o grau de dificuldade que as
primitivas assíncronas exigem na implementação de algoritmos de armazenamento de
mensagens e temporização. Quando um cliente faz uma requisição a um servidor este
pode não estar pronto para receber a mensagem enviada. Para que a mensagem não
seja perdida, podem ser implementado algoritmos de armazenamento de mensagens
(mail-box).
Para esse projeto, a viabilidade do uso de um Sistema distribuído ao invés de
um Sistema Centralizado se dá através das vantagens já apresentadas neste capítulo.
Justificamos o uso pelo propósito da pretensão de utilizar um sistema robusto para
manipular uma grande quantidade de dados e que apresente um baixo custo financeiro
em relação aos Sistemas Centralizados. Assim, utilizando técnicas de fragmentação de
dados e paralelização da aplicação, uma implementação distribuída tende a obter
resposta satisfatórias para o nosso intento.
Modelo Cliente-Servidor
O objetivo do modelo cliente-servidor é configurar o Sistema Operacional com
um conjunto de processos que colaboram entre si para a execução de uma tarefa,
denominados servidores e clientes. Servidores, como o próprio nome sugere, são
processos que oferecem serviços e acesso a recursos. Os clientes possuem processos
que requisitam os recursos e serviços oferecidos pelos servidores. Uma máquina pode
executar vários processos, servidores, clientes ou então uma combinação de ambos.
O modelo cliente-servidor utiliza um protocolo simples para comunicação do
tipo solicitação/resposta, isto evita a sobrecarga causada pelos protocolos dos modelos
OSI e TCP/IP devido ao tamanho cabeçalho e rotinas de controle de mensagens. Neste
tipo de protocolo, o cliente envia uma mensagem de solicitação de serviço ao servidor que
por sua vez recebe a mensagem, executa o serviço e devolve a resposta ao cliente ou
17

18. uma mensagem de erro informando o motivo pelo qual a solicitação não foi atendida. Veja
figura 2.1.1.
Figura 2.1.1 Modelo Cliente-Servidor
As vantagens deste modelo são:
Simplicidade
Não é necessário estabelecer ou finalizar conexão, pois basta o cliente enviar
uma solicitação ao servidor e aguardar pela resposta.
Baixa taxa de overhead na rede
As respostas enviadas pelo servidor em decorrência das solicitações dos
clientes servem como confirmação de recebimento da mesma.
Níveis de protocolos
No caso de protocolos idênticos entre as máquinas que estão interagindo
(cliente/servidor), são necessários apenas três níveis de protocolos (físico, enlace e
request/reply).
Um exemplo de um servidor pode ser observado abaixo:
servidor()
sempre faça
recebe(endereço de origem, mensagem)
processa(mensagem)
envia(endereço de origem, mensagem)
Figura 2.1.2 Exemplo de um servidor
Um exemplo de cliente para o servidor acima está demonstrado abaixo:
cliente()
faça
envia(endereço de origem, mensagem)
recebe(endereço de origem, mensagem)
Figura 2.1.3 Exemplo de um cliente
Dentre as primitivas que podem ser utilizadas, podem se destacar:
Bloqueadas ou não-bloqueadas
Por ser uma operação de E/S, tanto o cliente quanto o servidor podem ficar
18

19. bloqueados enquanto o Sistema Operacional envia e recebe uma mensagem. Neste
aspecto, se houver alguma falha, tanto o cliente quanto o servidor podem ficar
indefinidamente suspensos. Para evitar este tipo de situação, mecanismos de cronômetro
(timeout) são utilizados para interromper a operação, caso ela não seja completa.
Bufferizadas e não-bufferizadas
Bufferizadas as mensagens enviadas são armazenadas de forma
semelhante a uma caixa de e-mails, sendo assim, não há risco de perder alguma
mensagem enquanto o processo não está disponível para recebê-la. Assim que o
processo fica apto a receber mensagens, ele verifica a existência delas na caixa de e-
mails e as executa.
Não-bufferizadas as mensagens enviadas não ficam armazenadas, ou
seja, se o processo não estiver apto a receber, a mensagem é perdida. Esse tipo de
primitiva é mais simples de se implementar, porém, dependendo do caso, é necessário a
inserção de mecanismos de controle para evitar perda de mensagens.
Confiáveis e não-confiáveis
Confiáveis Há garantia de que a mensagem sempre será entregue,
portanto não é necessário nenhum tipo de tratamento especial para elas.
Não-confiáveis Não há garantia na entrega de mensagens entre os
processos. Para se tratar isso, existem basicamente três abordagens:
Admitir que a primitiva é não-confiável e deixar a responsabilidade de se
implementar uma comunicação confiável ao usuário;
Forçar o kernel a enviar mensagens de confirmação de recebimento (ACK);
Estabelecimento de um temporizador (timeout) para cada requisição enviada,
assim, se não houver resposta em um determinado período de tempo, a
mensagem é enviada novamente.
Clusters
Clusters, também chamados de Aglomerados, são uma implementação de
Sistemas Distribuídos que consiste em nós (computadores) de interconexão, podendo ser
monoprocessados ou multiprocessados, dentro de uma rede (LAN) de alta velocidade.
Esse aglomerado têm por objetivo processar tarefas como um único sistema, tirando
proveito do multiprocessamento fornecendo um sistema de grande capacidade de
processamento [DEI05].
Características de um Cluster
Segundo Tanenbaum [TAN95], as características fundamentais de um cluster
são:
Alto desempenho
A soma das capacidades de processamento de cada computador (nó) incluso
19

20. na rede pode atingir escala jamais possíveis para Sistema Centralizados. Mesmo fazendo
uso de multiprocessadores e de processadores vetoriais, somente será possível utilizar
milhares de processadores ao construir sistemas, sobre a forma de um enorme
aglomerado.
Escalabilidade
A escalabilidade diz respeito ao fato de ser possível acoplar ou desacoplar
máquinas no cluster, dependendo da necessidade de processamento. Existem algumas
características de escalabilidade a serem respeitadas:
Nenhuma máquina tem informação completa sobre o estado do sistema:
Nenhuma máquina tem informações completas sobre o estado do Sistema,
devido a sua independência de hardware e software das demais máquinas e
também pelo modo de comunicação através de mensagens que pode causar
congestionamento na rede se todas as máquinas começarem a trocar
informações o tempo todo.
Não existe uma sincronização de tempo global:
Não existe uma sincronização de tempo global real, ou seja, linear no tempo,
apenas uma sincronização lógica utilizada na troca de mensagens entre os
nós. Porque com tantas máquinas seria impossível sincronizar o relógio
interno do sistema com exatidão.
A falha de uma máquina não compromete o cluster:
A falha de uma máquina não deve comprometer o processo como um todo
para isso algoritmos de redirecionamento de serviços devem ser
implementados.
As máquinas tomam decisões baseadas nas informações locais:
As máquinas devem tomar decisões segundo as informações locais devido ao
seu modo de comunicação ser através de troca de mensagens. Porque
manter um nó atualizado com informações sobre todo o sistema poderia
causar muito tráfego na rede e conseqüentemente congestionamento na rede
e lentidão no sistema, o que foge da característica de um cluster.
Confiabilidade e tolerância à falha
Se uma máquina falhar isso não deve comprometer o sistema como um todo,
sendo para isso implementado algoritmos de redirecionamento de tarefas para outros nós
da rede.
Alta disponibilidade
Hardware e software podem ser replicados de modo a assegurar o serviço
oferecido.
Independência
20

21. Cada elemento possui um ou mais processadores, memória, dispositivos de
entrada/saída e seu próprio Sistema Operacional. Este elemento geralmente pode ser
desligado e até mesmo removido do cluster sem que isto afete o funcionamento dos
demais.
Transparência
O cluster deve se comportar como se fosse um único sistema, passando para
o usuário a imagem de um recurso único. Existem alguns tipos de transparências:
Locação o usuário não deve saber onde estão localizados os recursos tanto de
hardware quanto de software
Replicação o usuário não toma conhecimento das replicações do Sistema
Operacional, arquivos e outros recursos.
Migração os recursos podem ser removidos de um nó para outro sem a
necessidade de trocar seus nomes
Concorrência múltiplos usuários pode compartilhar recursos automaticamente
Paralelismo atividades distintas podem ocorrer em paralelo sem o conhecimento
do usuário
21

22. Comunicação entre processos no Cluster
Em um cluster, os nós são independentes, possuindo sua própria memória,
espaço de armazenamento e processador. A forma de comunicação entre eles é através
de troca de mensagens. A mensagem é um arranjo de parâmetros encapsulados enviado
através da rede de um computador a outro.
Entretanto a sincronização entre os nós é determinada pela lógica utilizada na
troca das mensagens [DEI05].
Para que haja interação entre recursos disponíveis no cluster, são
necessárias as implementações de alguns mecanismos de memória compartilhada
distribuída [DEI05]. Esses mecanismos consistem na existência de uma variável comum
entre todas as máquinas, permitindo que sempre que um processo modifique o valor
desta variável, esta seja atualizada nas demais máquinas. Um dos modelos mais comuns
de comunicação através de troca de mensagens entre processos é utilizando as primitivas
send e receive para envio e recebimento de mensagens, como ilustra a figura 2.2.1.
Figura 2.2.1 - Modelo de comunicação com send e receive. A atualização de uma variável
a processos em máquinas diferentes utilizando as primitivas send/receive.
Esta comunicação é viabilizada através da Invocação Remota de Método
(RMI) que ajuda o programador neste tipo de aplicação.
22

23. Cluster Homogêneo e Heterogêneo
Segundo Marcos Pitanga [PIT03], um cluster é homogêneo quando todos os
seus nós são dotados das mesmas características (software e hardware) e compartilham
a mesma rede de comunicação. E um cluster é heterogêneo quando os seus nós se
diferenciam em características ou rede de comunicação.
A característica de um cluster ser ou não homogêneo reflete nas regrar a
serem utilizadas para o balanceamento de carga das tarefas que devem ser executadas.
Eventualmente, no particionamento de uma tarefa, ao se balancear a carga em um cluster
homogêneo, todos os nós receberam cargas iguais, já que compartilham das mesmas
características. Evidentemente, possuem o mesmo poder de processamento.
Em um cluster heterogêneo deve-se ter cautela ao distribuir as cargas entre
os nós, pois sendo máquinas diferentes umas das outras, seu poder de processamento
também difere, Isto exige que seja implementado um algoritmo gerenciador, que analise o
poder de processamento de cada nó atribuindo-lhe um peso que servirá de parâmetro e
fator decisório para que seja distribuída uma carga compatível com a capacidade de
processamento de cada nó.
Embora um cluster homogêneo seja mais atraente por não se preocupar em
balancear a carga de tarefas distribuídas, é fato que com a sua ampliação ele se tornará
heterogêneo salvo os casos em que não mais será modificado ou encontre máquinas
exatamente iguais para a ampliação.
23

24. Tipos de Cluster
Segundo Deitel [DEI05], há três tipos principais de clusters: cluster de alto
desempenho, de alta disponibilidade e de balanceamento. Estes clusters seguem um
padrão de características distintos que depende da aplicação.
Cluster de Alto Desempenho
Neste tipo de cluster, todos os nós são utilizados para executar o serviço. Ele
é aplicado em problemas computacionais de grande escala que podem se divididos e
executados paralelamente.
Clusters de Alta Disponibilidade
Em clusters de alta disponibilidade, alguns nós são usados para executar
serviços, enquanto que outros são reservados para assumir o lugar de uma máquina no
caso de falha assumindo a execução da tarefa. Este modelo de cluster é muito utilizado
em tarefas de missão crítica onde não pode haver falhas de sistema e para se conseguir
este nível de confiabilidade é necessário que haja redundância de hardware e software.
Esta característica é oferecida pelos clusters de alta disponibilidade onde há replicação de
software e hardware.
Clusters de Balanceamento de Cargas
Nesse tipo de cluster existe um nó coordenador que distribui as tarefas entre
os demais nós do cluster, de modo que cada um receba uma quantidade de tarefas à
executar compatível com o seu poder computacional. Para tanto é necessário que seja
atribuído a cada máquina um peso que represente o seu desempenho computacional
para que sirva de parâmetros de algoritmos de balanceamento que tomarão decisões com
base nestes dados. Os Clusters de Balanceamento de Cargas são utilizados em
aplicações de e-business com grandes volumes de usuários.
Exemplos de Clusters
Cluster Beowulf
Desenvolvidos nos laboratórios da NASA, o projeto Beowulf
[PIT03][BEO05](1994), liderado por Thomas Sterling, tinha como objetivo proporcionar
uma ferramenta de baixo custo financeiro que pudesse resolver grandes tarefas
computacionais em ciências espaciais e terrestres do Goddard Space Flight Center
(NASA). Na sua primeira versão o cluster Beowulf era dotado de 16 computadores com
processador Intel DX 4 ligados via rede Ethernet.
O Beowulf utiliza o modelo cliente/servidor como acesso a todos o nós através
de uma conexão remota ao nó servidor.
O nó servidor tem como objetivo controlar o cluster, monitorando e
distribuindo tarefas. Os demais nós (escravos) são exclusivamente dedicados para o
24

25. processamento das tarefas enviadas pelo servidor, podendo ou não ter dados ou discos
rígidos. Abaixo segue uma ilustração de um cluster Beowulf (Figura 2.2.3).
Figura 2.2.3 - Cluster Beowulf
Devido ao fato de clusters Beowulf poderem ser construídos com uma
variedade de componentes de hardware e software distintos, foi proposto em 1998 um
esquema de classificação com o intuito de simplificar as referências sobre o Beowulf e
responder aos diferentes tipos de hardware e software:
Beowulf classe 1:
Cluster Beowulf de classe 1 são construídos com componentes comuns do
mercado encontrados em pelo menos 3 catálogos nacionais e globais de venda de
componentes.
As vantagens do cluster Beowulf são:
Hardware disponível de vários fornecedores (preço baixo, fácil
manutenção);
Independência quanto ao fornecedor dos equipamentos;
Apoio a drivers Linux comuns;
Normalmente baseado em padrões (SCSI, EIDE, PCI, Ethernet, etc.).
Desvantagem de um cluster Beowulf classe 1:
Desempenho inferior ao cluster Beowulf classe 2.
Beowulf classe 2:
Cluster Beowulf de classe 2 são simplesmente quaisquer máquinas que não
passe no teste de certificação de disponibilidade. Esta classe geralmente oferece maior
desempenho a um custo financeiro maior em relação ao cluster Beowulf classe 1.
Vantagens:
Desempenho geralmente maior em relação aos clusters Beowulf classe 1
25

26. dependendo da configuração (uso de uma LAN de 12 Gb/s só aumentaria
o desempenho de aplicações altamente acopladas).
Desvantagens:
Suporte a drivers de dispositivos variados;
Dependência de um único fornecedor de hardware;
Geralmente apresentam um custo financeiro bem mais elevado que os
Beowulf classe 1.
Uma classe não necessariamente melhor que a outra depende
exclusivamente do custo/desempenho que o sistema requer.
26

27. Invocação Remota de Métodos (RMI)
A RMI é uma tecnologia desenvolvida pela Sun Microservice, que habilita um
processo que está executando em uma máquina invocar um método de um objeto em
uma máquina remota [HOR01] [DEI01]. Essa tecnologia trata-se de um protocolo que
permite que uma invocação a um método remoto seja feita nos mesmos moldes de uma
chamada local, deixando os detalhes de montagem dos parâmetros e transporte
transparente para o programa de emite a chamada [HOR01] [DEI01]. A figura 2.4.1
mostra a arquitetura básica de um RMI, composta pelo RMIRegistry, o Server e o Client.
Figura 2.4.1 Arquitetura Básica RMI
A RMI possibilita o desenvolvimento de aplicações distribuídas sem ter
programas sockets explicitamente, ou seja, torna toda a parte de sockets transparente ao
usuário programador. A sua arquitetura é caracterizada pelas camadas de software a
seguir [DEI01]:
Stub: o stub Java é uma interface entre o processo cliente e o objeto remoto.
Quando o processo cliente faz uma invocação de um método remoto a camada
stub é chamada primeiro, que recebe os parâmetros, serializa-os para montar a
mensagem e os envia para a camada RRL (Remote Reference Layer). A
serialização de objeto permite que programas em Java possam enviar e receber
objetos.
RRL (Remote Reference Layer): a camada RRL recebe os parâmetros, já
serializados, do stub e através da camada de transporte envia a mensagem
(parâmetros) para o servidor. A RRL do lado do servidor recebe a mensagem e
dirige ao Skeleton.
Skeleton: o skeleton é uma estrutura análoga ao stub cliente, que recebe os
parâmetros da RRL, de-serializa, identifica o método a ser invocado e faz a
chamada para esse método. Ao concluir o método, o skeleton serializa o resultado
e o envia ao cliente através da RRL e o stub.
Para a implementação de RMI, é necessário que exista uma classe servidor,
na qual está a implementação dos métodos RMI a serem disponibilizados para os
clientes. Ao ser inicializado, o servidor deve se registrar no RMIRegistry para que os
clientes possam utilizar os seus serviços.
Um cliente RMI, ao tentar executar um método implementado por RMI, faz
uma consulta de nome (lookup) no RMIRegistry e este retorna o endereço IP do servidor
RMI que contém o método que se deseja. Com isso, o cliente pode enviar diretamente os
parâmetros através do stub ao skeleton do servidor que executará a função e retornará o
resultado ao cliente.
27

28. RMI-Registry
Para tornar o objeto servidor disponível para as chamadas remotas, eles
devem ser registrados no RMI-Registry. O RMI-Registry é o servidor de nomes padrão na
plataforma Java.
Quando um nó é acoplado a rede de um sistema distribuído, este informa ao
RMI-Registry o seu endereço de IP e o nome do objeto que estará disponível para
executar as tarefas, de modo que ao solicitar, o cliente obtenha através do RMI-Registry a
localização do servidor e o objeto remoto.
Cliente RMI-Registry Servidor
2 Requisição da 1 Registry/
Localização método
3 Localização
4 Requisição de serviço
5 - Resposta
REDE
Fig. 2.4.2 Arquitetura de um cluster usando RMI-Registry.
1 O servidor é conectado à rede e/ou o sistema operacional é iniciado, então o sistema
localiza o servidor de nomes ( RMI-Registry) e se registra informando seu IP e o nome do
método que estará disponível para o cliente;
2 O cliente requisita ao RMI-Registry a localização do método que esta necessitando;
3 O RMI-Registry retorna uma resposta com a localização da máquina que tem o
método disponível;
4 O cliente faz uma requisição de serviço ao servidor;
5 O servidor responde à requisição;
Exemplo de programa em RMI
Abaixo será mostrado um exemplo de utilização do RMI extraído de [MAS04]
com todos os códigos fontes necessários:
Ola.java (interface)
/*
* Esse programa implementa a interface dentro do RMIRegistry
*/
import java.rmi.*;
public interface Ola extends Remote{
28

29. public String getMensagem() throws RemoteException;
}
OlaImpl.java (implementação do servidor)
/*
* Esse programa implementa o servidor RMI
*/
import java.rmi.*;
import java.rmi.server.UnicastRemoteObject;
public class OlaImpl extends UnicastRemoteObject implements Ola{
public OlaImpl() throws RemoteException{
super();
}
public String getMensagem(){
return("Ola - Meu primeiro exemplo RMI");
}
public static void main(String args[]){
try{
OlaImpl obj = new OlaImpl();
Naming.rebind("localhost/OlaServer",obj);
System.out.println("Servico registrado. Servidor no ar. Ok!");
} catch (Exception e){
System.out.println("Problemas no registro do objeto no servidor");
System.out.println("Erro:"+e.getMessage());
}
}
}
OlaCliente.java (cliente)
/*
* Esse programa implementa um cliente RMI
*/
import java.rmi.*;
public class OlaCliente{
public static void main(String args[]){
Ola o;
String msg;
System.out.println("Cliente no ar... conectando com servidor");
try{
o = (Ola)Naming.lookup("localhost/OlaServer");
msg = o.getMensagem();
System.out.println("Recebido="+msg);
} catch (Exception e){
System.out.println("Problemas ao conectar com servidor");
System.out.println("Erro:"+e.getMessage());
}
}
}
29

30. Sistema de Arquivo de Rede (NFS Network File System)
O sistema de Arquivo de Rede (NFS) é um padrão de compartilhamento de
arquivo de rede suportado pela maioria das plataformas Linux [DEI05]. Seu
funcionamento se dá através da comunicação entre cliente e servidor.
Antes de um cliente NFS acessar um arquivo remoto, ele deve usar o
protocolo de montagem (um mecanismo que traduz um endereço de arquivo para um
manipulador de arquivo) para montar o diretório que retém o arquivo remoto. Um
manipulador de arquivo identifica um arquivo remoto por seu tipo, localização e
permissões de acesso. Montar implica em mapear um diretório de arquivo remoto para o
diretório local de um cliente.
Para montar o sistema de arquivo o cliente NFS faz uma chamada local ao
stub do cliente e ao receber a solicitação de montagem, o skeleton do servidor passa a
chamada ao servidor NFS. O servidor NFS examina o seu local de arquivos e exporta o
diretório local de arquivos que satisfaz a requisição do cliente, o que significa que o
servidor torna o diretório local de arquivos disponível para o cliente. Então o skeleton do
servidor retorna um manipulador de arquivos ao diretório local de arquivo, o que permite
que o cliente acesse remotamente o diretório de arquivos exportado. O cliente remoto usa
esse manipulador de arquivos em todas as requisições subseqüentes de arquivos no
diretório de arquivos exportado.
O NFS prevê delegações ao cliente para a manipulação de arquivos. Quando
o servidor concede uma delegação de leitura, nenhum outro cliente pode escrever para
aquele arquivo a um cliente. Se um outro cliente requisitar acesso de escrita a um arquivo
com a delegação de leitura ou de escrita ou se o cliente requisita acesso de leitura com
delegação de escrita, o servidor revogará a delegação e requisitará que o cliente original
descarregue o arquivo para o disco.
Para uma maior segurança na comunicação entre o cliente e o servidor, o
NFS suporta diversos algoritmos de criptografia, usados quando estabelece sessões de
comunicação, criptografando cada requisição. O NFS também oferece uma autenticação
de clientes por meio das chamadas remotas, evitando que clientes não autorizados
acessem os dados.
30

31. Capítulo 3
Este capítulo apresenta uma introdução à
biologia, biologia computacional e aos
algoritmos computacionais para
comparação de DNAs que serão
utilizados no projeto.
31

32. Biologia Computacional
Segundo Setúbal [SET94], Biologia Computacional pode ser entendida como
sendo a aplicação de técnicas e ferramentas da computação aos problemas da biologia e
entre as diversas áreas da biologia, aquela que a aplicação de técnicas computacionais
tem sido mais necessária é a biologia molecular, em particular na sua interface com a
genética. Ele afirma também que diversas áreas da computação contribuem para o
estudo da biologia molecular, como teoria da computação, através da formulação de
algoritmos para diversos problemas que surgiram recentemente. A teoria e prática de
banco de dados, também se faz necessária, para lidar com enormes massas de
informações oriundas dos avanços em técnicas laboratoriais.
O objetivo deste capítulo será desenvolver e demonstrar como algumas das
ferramentas computacionais podem auxiliar com o trabalho dos biólogos, como
comparação e similaridade que precisa ser efetuados no DNA. Existem outras aplicações
que são de grande utilidade para a biologia, porem não serão comentada neste trabalho.
Conceitos de Biologia
As proteínas e ácidos nucléicos são as moléculas fundamentais para todo o
ser vivo. O ácido desoxirribonucléico (DNA) é o constituinte básico dos genes. Os genes
por sua vez, contém todas as informações necessárias para o desenvolvimento desse
organismo. O conjunto de todos os genes de um indivíduo é chamado de genoma. Então,
pode-se dizer que o genoma é a especificação primaria e fundamental de um ser vivo.
[ROB03] afirma que os genes podem ser analisados sob três ângulos, porem,
para a justificativa desse projeto utilizaremos o ponto de vista molecular, que define o
gene como: a seqüência de DNA que contém a informação necessária para sintetizar uma
molécula de RNA, e a partir dele construir uma proteína. Os Genes são os segmentos
funcionais do DNA e calcula-se que existam cerca de 100.000 genes distribuídos nos 23
pares de cromossomos.
As proteínas são cadeias de aminoácidos necessárias nos organismos para o
seu bom funcionamento. A falta de alguma proteína no organismo pode causar sérios
problemas e possivelmente a sua morte. Então podemos afirmar que uma mutação nesse
DNA pode causar o comprometimento do organismo.
Com a aplicação do conhecimento sobre o DNA, poderemos sintetizar novos
remédios a fim de curar ou minimizar os efeitos de doenças até então sem tratamento.
Também a aplicação na engenharia genética como pode ser citado o caso de clonagem
de animais como ovelhas, vacas, cachorros e primatas. Outra área importante que
podemos observar nos tempos modernos é o emprego desse conhecimento na
agricultura, no desenvolvimento de produtos de consumo com maior qualidade, mais
resistentes a pragas e condições do tempo e em maior quantidade para atender a
população que tende ao crescimento.
Se fossemos capazes de ler um genoma, poderíamos predizer todas as
características que o seu possuidor terá ou será capaz de ter. O problema é que os
genomas são muito extensos, na Tabela 3.1 é demonstrado o tamanho do genoma de
diversas espécies.
Espécie Nome Popular Tamanho total do Genoma(pares de base)
32

33. Bacteriófago vírus 5 x 10 4
Escherichia coli Bactéria 5 x 10 6
Saccharomyces cerevisiae Levedura 1 x 10 7
Caenorhaditis elegans Verme 6 x 10 8
Drosophila melanogaster Mosca 2 x 10 8
Homo sapiens Homem 3 x 10 9
Tabela 3.1: Tamanho do genoma de algumas espécies
Ao contrário do que muitos pensam, biologia computacional não se resume à
comparação de seqüências ou casamento aproximado de padrões, embora o resultado
deste trabalho seja exatamente isso, porém utilizando um Sistema Distribuído. Existem
diversos outros problemas biológicos nos quais algoritmos da computação são utilizados,
como: união de conjunto disjuntos, ordenação topológica, tabelas de hashing entre outros.
Novos problemas da biologia computacional exigem a criação de novas técnicas e novos
algoritmos que em muitos casos são úteis em outras aplicações.
Para tal auxílio, não abordaremos temas da biologia molecular e bioquímica,
pois acabaria fugindo do foco, e sim trataremos os dados biológicos como apenas um
alfabeto de 4 letras, sendo elas: A (Adenina), C (Citosina), G (Guanina) e T (Timina).
Essas letras são as bases encontradas no DNA. Dependendo da aplicação que poderá
ser usada após o término deste projeto à base U (uracil) poderá ser utilizada no lugar do T
(Timina) caso seja trabalhado com RNA (ácido ribonucléico), mas para isso será
necessário efetuar modificações na codificação do projeto, que poderá ser feito em
futuros trabalhos.
Comparação de seqüências e Alinhamento
Segundo Setúbal [SET94], a operação de comparação é a mais básica em
biologia computacional e apresenta duas seqüências de DNA, por exemplo:
GACGGATTAG e GATCGGAATAG. Pode-se notar a semelhança entre as duas
seqüências se as colocarmos alinhadas conforme apresentado abaixo:
GA-CGGATTAG
GATCGGAATAG
As únicas diferenças são um T a mais na segunda seqüência e uma troca de
A por T na quarta posição da direita para esquerda. Também foi necessário introduzir um
buraco (indicado pelo hífen) na primeira seqüência para que as bases iguais antes e
depois do buraco se alinhassem nas duas seqüências.
O alinhamento entre as seqüências mostra a similaridade entre elas, ou seja,
poderemos afirmar com um determinado numero (que é a pontuação total do alinhamento
entre as seqüências) quanto uma determinada espécie é similar à outra. No caso deste
projeto, como focaremos apenas essa similaridade, os biólogos poderão utilizar essa
ferramenta para classificação de possíveis espécies novas que forem descobertas.
Definiremos com base em [SET94], o entendimento do alinhamento. As duas
seqüências não precisam ser do mesmo tamanho e alinhamentos podem conter buracos
em qualquer seqüência. Então um alinhamento é a inserção de buracos em pontos
arbitrários ao longo das seqüências de modo que elas fiquem com o mesmo
comprimento, entretanto um buraco de uma seqüência não pode ser alinhado com um
buraco de outra seqüência e por fim, buracos podem ser colocados tanto no início como
33

34. no final das seqüências.
Dado um alinhamento entre duas seqüências, podemos atribuir uma
pontuação, esta pontuação é definida pelo pesquisador da área biológica dependendo de
como ele deseja ponderar a comparação. Neste projeto, utilizaremos como padrão os
mesmos valores ponderados utilizados em [SET94]. Por ex:
Cada coluna do alinhamento receberá um certo numero de pontos e a
pontuação total do alinhamento será a soma dos pontos atribuídos à suas colunas. Se a
coluna tiver duas bases iguais receberá 1 ponto, se a coluna tiver duas bases diferentes
receberá 1 e finalmente se a coluna possuir uma base e um buraco receberá 2. O
alinhamento ótimo será aquele que tiver pontuação máxima. Esta pontuação máxima
chamaremos de similaridade entre as duas seqüências. Em geral pode haver mais de um
alinhamento com pontuação máxima.
Por exemplo, a pontuação da seqüência anterior onde nove colunas com
bases iguais, uma coluna com bases desiguais e uma coluna com buraco, então a sua
pontuação é a seguinte:
9 * 1 + 1 * (-1) + 1 * (-2) = 6
Para melhor entendimento do algoritmo que calcula o alinhamento, será
utilizada a seguinte seqüência:
AAAC
AGC
Para encontrar um alinhamento ótimo para esse par de bases há três
possibilidade relacionadas abaixo:
AAA C
AG C
AAAC -
AG C
AAA C
AGC -
Com este raciocínio, usaremos um método recursivo para achar o valor de um
alinhamento ótimo, define-se uma função similarity(s1, s2) que corresponde à similaridade
entre s1 e s2
Calcule similarity (AAA, AG) +1
Calcule similarity (AAAC, AG) -2
Calcule similarity (AAA, AGC) -2
O problema deste método é que se aplicado diretamente, vai gerar um
número exponencial de chamadas recursivas e se cada chamada gera outras três, sendo
em duas delas o número total de caracteres envolvidos juntando as duas seqüências
diminui apenas de um, teremos no mínimo 2 m / n chamadas, onde m e n representam os
comprimentos das seqüências originais.
Contudo, muitas destas chamadas são redundantes, portanto não há
necessidade de serem calculadas duas vezes, desde que sejam guardadas de maneira
34

35. que possam ser consultados rapidamente como mostrado na figura 3.2.1.
AAA
AG
C
C
AA AAA AA
A
A CA AG
G G C
A AA A AA AAA AA A AA A
A
A AA A AA CA A
A A A
A AG
A
G G G G C
Figura 3.2.1 Árvore de Chamadas recursivas
Será utilizada a técnica de programação dinâmica, cuja qual deve-se observar
que embora um método gere um número muito grande de chamadas recursivas, o
numero total de instancias de entrada é limitado, de modo que o calculo pode ser feio
uma só vês e armazenado para consultas posteriores, se necessário. Na maioria dos
casos, uma matriz é usada para guardar resultados parciais.
Se observarmos as chamadas recursivas, podemos afirmar que o método da
figura 3.2.1 utiliza sempre um prefixo da primeira seqüência e um prefixo da segunda
seqüência. Há m +1 prefixos de s1 e n + 1 prefixos de s2, incluindo os vazios. Dessa
forma, há apenas (m + 1 ) (n + 1) possíveis combinações de argumentos
Toda a recursão tem seus casos base, e neste determinado problema, os
casos bases são aqueles em que a seqüência vazia é comparada a outra, isto é, o prefixo
vazio de uma seqüência é comparado a um prefixo da outra. Nestes casos, o único
alinhamento possível é colocar-se tantos buracos na seqüência vazia quantos
necessários para igualar o comprimento da outra seqüência, resultando em uma
pontuação de -2k, onde k é o comprimento da outra seqüência.
A figura 3.2.2 ilustra uma matriz bidimensional usada para a comparação da
seqüência AAAC com AGC. Cada célula contém a pontuação de um alinhamento ótimo
entre prefixos das seqüências dadas. Se chamarmos AAAC de s1 e AGC de s2, e se
convencionarmos que s[1...j] indica o prefixo com tamanho j de s1, então cada célula (i,j)
contem o resultado da comparação de s1[1...i] com s2[1...j]. Na matriz da figura 3.2.2, as
células das bordas superior e esquerda foram inicializadas com -2 vezes a posição da
célula, de acordo com a observação sobre casos base que fizemos anteriormente.
35

36. A G C
0 -2 -4 -6
1 -1 -1
A -2 1 -1 -3
1 -1 -1
A -4 -1 0 -2
1 -1 -1
A -6 -3 -2 -1
-1 -1 1
C -8 -5 -4 -1
Figura 3.2.2 Matriz Bidimensional de similaridade entre as seqüências S1 e S2
Uma breve explicação de como foi montada a matriz
Na matriz da figura 3.2.2, as células das bordas superior (primeira linha) e
esquerda (primeira coluna) foram inicializadas com -2 vezes a posição da célula, de
acordo com a observação sobre casos base que fizemos anteriormente. Ou seja, para as
células da primeira linha fixa o valor do j e calcula-se utilizando o valor de i ficando:
posição C(1,0), -2*1= -2;
posição C(2,0), -2*2= -4;
posição C(3,0), -2*3= -6
O procedimento foi semelhante às células da primeira coluna, ou seja, fixando
o valor de i e utilizando o valor de j para o calculo, ficando:
posição C(0,1), -2*1= -2;
posição C(0,2), -2*2= -4;
posição C(0,3), -2*3= -6;
posição C(0,4), -2*4= -8
Nas células com i=>1 e j =>1 são acrescentados índices, que são calculados
da seguinte forma:
As células em que o cruzamento das mesmas bases se coincidem, possuem
o índice 1, caso contrario o índice é 1. Então podemos verificar esse método observando
as células C(1,1), C(1,2), C(1,3) e C(3,4) possuem o índice 1 enquanto as demais células
possuem o índice -1. Os valores das células i = j => 1 é definido como o valor máximo
36

37. entre :
(i-1,j) + b, ou seja, o valor da célula à esquerda mais b (onde valor de b é -2)
(i-1,j-1) + índice, ou seja, o valor da célula diagonal esquerda superior mais o
índice da própria célula
(i,j-1) + b, ou seja, o valor da célula acima mais b (onde valor de b é -2)
O resultado que possuir o maior valor, será o valor da célula. Podemos
acompanhar esse método a partir da célula (1,1), onde:
o valor da célula superior (célula (0,1)) é -2 mais o valor de b o resultado é 4;
o valor da célula diagonal esquerda superior (célula (0,0)) é 0 mais o índice o
resultado é 1;
o valor da célula esquerda (célula (1,0)) é -2 mais o valor de b o resultado é -4
Comparamos e verificamos que o maior resultado obtido pelo método é 1,
portanto o valor desta célula (célula (1,1)) será 1. Prosseguindo com o algoritmo, será
possível calcular tanto a célula abaixo (célula(2,1)) ou a célula à direita (célula(1,2)).
Vamos prosseguir a explicação com o calculo da célula à direita (célula (1,2)):
o valor da célula superior (célula (0,2)) é -4 mais o valor de b o resultado é 6
o valor da célula diagonal esquerda superior (célula (0,1)) é -2 mais o índice o
resultado é 3
o valor da célula esquerda (célula (1,1)) é 1 mais o valor de b o resultado é 1.
Portanto, o maior valor entre os três comparados é -1, ficando esse o valor da
célula.Agora calcularemos a célula (2,1):
o valor da célula superior (célula (0,1)) é 1 mais o valor de b o resultado é -1
o valor da célula diagonal esquerda superior (célula (1,0)) é -2 mais o índice o
resultado é -1
o valor da célula esquerda (célula (2,0)) é -4 mais o valor de b o resultado é -6
Neste caso podemos observar que para esta célula existem duas
possibilidades de valores máximos, que é -1, então este será o valor da célula.
Agora podemos calcular o valor de três células que podem ser: célula (1,3);
célula(2,2); e célula(1,3)
É por esse motivo que temos o paralelismo, várias células podem ser
calculadas ao mesmo tempo, porem como as seqüências possuem um tamanho elevado
o projeto será paralelizar blocos de células a serem processadas. Não daremos
continuidade, pois o texto ficaria muito extenso e cansativo.
As setas que são apresentadas na figura 3.2.2 apontam para as células de
onde foram obtidos os maiores valores como é o caso das células: c(2,1); c(2,3); c(3,1);
c(3,2) e c(4,2). Ou seja, existe mais de uma possibilidade de valor máximo para a célula e
essas setas são utilizadas para verificar o melhor alinhamento entre as duas seqüências.
Um outro detalhe importante, é que toda seqüência inserida nos algoritmos,
tanto de alinhamento, quanto de similaridade, devem ser validadas antes de começar a
comparação, a validação é feita conforme o algoritmo abaixo:
37

38. Algoritmo para validação de seqüências de DNA
Descrição: Verifica se a sequência de DNA é uma sequência válida
Nome do método: isValid()
Classe a que pertence: DNAString
Atributos do método: Private
Argumentos do Sequencia de caracteres a ser validada
método:
Retorno do método: 1 se validado, 0 se falhou.
Português estruturado do método isValid():
s1: vetor da seqüência de DNA (vetor de caracteres)
|s1|: número de elementos do vetor da seqüência de DNA (inteiro)
m, i: inteiros
isValid()
- Supomos |s1| = m.
para i = 0 a m faça
se s1[i] != 'A' ou s1[i] != 'a' então
se s1[i] != 'T' ou s1[i] != 't' então
se s1[i] != 'C' ou s1[i] != 'c' então
se s1[i] != 'G' ou s1[i] != 'g' então
se s1[i] != '-' então
retorna 0;
retorna 1;
Similaridade distribuída (CGM/BSP)
Em [SON02], é demonstrado um algoritmo de granularidade grossa chamado
de BSP, que afirma melhorar o desempenho razoavelmente se for implementado em
máquinas paralelas com memória principal distribuída. O Algoritmo BSP consiste em uma
seqüência de várias etapas, separadas por um controle de sincronização. Nessas etapas,
cada processador executa um conjunto de operações independentes que usam dados
locais disponíveis para cada processador no começo da etapa, que consiste também na
comunicação (envio e recebimento de mensagens). N processadores em uma etapa
corresponde a enviar ou receber n mensagens em cada processador.
Outro algoritmo apresentado por [SON02] é o CGM, onde os processadores
são interconectados por qualquer tipo de conexão e consiste em um conjunto de
execuções enquanto alternam entre processamento local e processamento global (troca
de mensagens). Normalmente durante a execução é utilizado o algoritmo que melhor
processa os dados localmente. O algoritmo CGM é um caso especial do BSP onde todas
as operações de comunicação das etapas são terminadas em n processadores. Estes
algoritmos são apresentados na seção de Algoritmos de alinhamento e similaridade
utilizados neste projeto. Com a implementação deste algoritmo teremos uma ordem de
complexidade de O(mn/p) onde m e n são o tamanho das seqüências e p o numero de
processadores disponíveis e, comparamos esta complexidade através das medidas de
tempo obtidas com os testes de desempenho.
Para resolver o problema de similaridade sobre o modelo CGM/BSP, divide-se
uma seqüência C de tamanho n(onde C é a segunda seqüência) em p partes, de
tamanhos n/p, e cada processador Pi, 1<=i<=p, recebe a seqüência A e a i-ésima parte de
C (c(i-1) n/p+1...ci n/p).
Cada processador Pi computa os elementos Si(r,s) da submatriz Si, onde
38

39. 1<=r<=i n/p usando apenas 3 elementos pré-computados Si(r-1,s), Si(r-1,s-1), Si(r,s-1),
pois há somente 3 formas de se calcular um alinhamento entre A[1..r] e C[1..s]. Pode-se
alinhar A[1..r] com C[1..s-1] e marcar um espaço com C[s], ou alinhar A[1..r-1] com C[1..s-
1] e marcar A[r] com B[s], ou alinhar A[1..r-1] com C[1..s] e marcar um espaço com A[r].
Para calcular a submatriz Si, cada processador Pi usa o melhor algoritmo
seqüencial local. É fácil de ver que o processador Pi, i>1, pode somente iniciar a
computação de elementos Si(r,s) após o processador Pi-1 ter computado parte da
submatriz Si-1(r,s).
Denotado por Rki, 1<=i, k<=p, todos os elementos do limite direito (ultima
coluna a direita) da k-ésima parte da submatriz Si. Mais precisamente, Rki = {Si(r,i n/p),
(k-1)m/p +1<=r<=km/p}.
A idéia do algoritmo é a seguinte: Após computar a k-ésima parte da
submatriz Si, o processador Pi envia para o processador Pi+1 os elementos de Rki.
Usando Rki, o processador Pi+1 pode computar a k-ésima parte da submatriz Si+1. Após
p-1 turnos, o processador Pp recebe R1p-1 e computa a primeira parte da submatriz Sp.
No turno 2p-2, o processador Pp recebe Rpp-1 e computa a p-ésima parte da submatriz
Sp e finaliza o processamento.
Figura 3.2.3 Comunicação entre as etapas, semelhante ao Scheduling
Usando esta programação (figura 3.2.3), pode-se ver que na primeira iteração
somente o processador P1 trabalha. Na segunda iteração, os processadores P1 e P2
trabalham. É fácil verificar que na iteração k, todos os processadores Pi trabalham, onde
1<=i<=k.
39

40. Algoritmos de alinhamento e similaridade utilizados
como base neste projeto
Algoritmo básico do método alignment() da classe DNA
Descrição: Traça o alinhamento ótimo entre duas seqüências de DNA utilizando a
matriz gerada pelo método similarity()
Nome do método: alignment()
Classe a que pertence: DNA
Atributos do método: Private
Argumentos do método: Inteiro FirstSequenceCount
Inteiro SecondSequenceCount
Inteiro AuxiliarCount
Retorno do método: Inteiro AuxiliarCount caso não ocorra erro ou inteiro 0 caso ocorra erro.
Os parâmetros do método alignment() ao ser invocado devem ser:
FirstSequenceCount: tamanho do vetor da primeira seqüência de DNA;
SecondSequenceCount: tamanho do vetor da segunda seqüência de DNA;
AuxiliarCount: indiferente.
Português estruturado do método alignment():
s1: vetor da primeira seqüência de DNA (vetor de caracteres)
s2: vetor da segunda seqüência de DNA (vetor de caracteres)
i: primeiro parâmetro do método, representa o marcador do vetor da primeira seqüência de DNA (inteiro)
j: segundo parâmetro do método, representa o marcador do vetor da segunda seqüência de DNA (inteiro)
t: terceiro parâmetro do método, representa o marcador das seqüências alinhadas (inteiro)
alin1: vetor alinhado da primeira seqüência de DNA inserida. (vetor de caracteres)
alin2: vetor alinhado da segunda seqüência de DNA inserida. (vetor de caracteres)
a: matriz[|s1|][|s2|] que representa o número de similaridades entre a primeira e a segunda seqüências de
DNA. (matriz de inteiros)
b: custo do buraco vazio (inteiro)
c: Custo de tipos iguais (inteiro)
d: Custo de tipos diferentes (inteiro)
alignment(i,j,t)
se i = 0 e j = 0 então
t 0
senão se i > 0 e a[i,j] = a[i-1,j] + b então
alignment(i-1,j,t)
t t+1
alin1[t] s1[i-1]
alin2[j] -
senão se i > 0 e j > 0 e a[i,j] = a[i-1,j-1] + pontuação(i,j) então
alignment(i-1,j-1,t)
t t+1
alin1[t] s1[i-1]
alin2[j] s2[j-1]
senão se j > 0 e a[i,j] = a[i,j-1] + b então
alignment(i,j-1,t)
t t+1
alin1[t] -
alin2[j] s2[j-1]
retorna t
pontuação(i,j)
se s1[i] = s2[j] então
retorna c
senão
retorna d
40

41. Algoritmo básico do método similarity() da classe DNA
Descrição: Gera a pontuação de um alinhamento ótimo em matriz
Nome do método: similarity()
Classe a que pertence: DNA
Atributos do método: Private
Argumentos do método: Nenhum
Retorno do método: Inteiro 1 caso não ocorra erro ou inteiro 0 caso ocorra erro.
Português estruturado do método similarity():
s1: vetor da primeira seqüência de DNA (vetor de caracteres)
s2: vetor da segunda seqüência de DNA (vetor de caracteres)
|s1|: número de elementos do vetor da primeira seqüência de DNA (inteiro)
|s2|: número de elementos do vetor da segunda seqüência de DNA (inteiro)
a: matriz[|s1|][|s2|] que representa o número de similaridades entre a primeira e a segunda seqüências de
DNA. (matriz de inteiros)
b: custo do buraco vazio (inteiro)
c: Custo de tipos iguais (inteiro)
d: Custo de tipos diferentes (inteiro)
m, n, i, j, valor1, valor2, valor3: inteiros
similarity()
- Supomos |s1| = m e |s2| = n.
para i 0 a m faça
a[i,0] i*b
para j 0 a n faça
a[j,0] j*b
para i 0 a m faça
para j 0 a n faça
a[i,j] maximo(a[i-1,j] + b,
a[i-1,j-1] + pontuação(i,j),
a[i,j-1] + b)
retorna a[m,n]
pontuação(i,j)
se s1[i] = s2[j] então
retorna c
senão
retorna d
maximo(valor1, valor2, valor3)
se valor1 > valor2 e valor1 > valor3 então
retorna valor1
senão se valor2 > valor3 então
retorna valor2
senão
retorna valor3
41

42. Algoritmo básico do método CGM/BSP() da classe DNA
Descrição: Gera a pontuação de um alinhamento ótimo de forma distribuída
Nome do método: CGM/BSP()
Classe a que pertence: DNA
Atributos do método: Public
Argumentos do Nenhum
método:
Retorno do método: Fragmento da matriz de alinhamento.
Português estruturado do método CGM/BSP():
s1: vetor da primeira seqüência de DNA (vetor de caracteres)
s2: vetor da segunda seqüência de DNA (vetor de caracteres)
|s1|: número de elementos do vetor da primeira seqüência de DNA (inteiro)
|s2|: número de elementos do vetor da segunda seqüência de DNA (inteiro)
a: matriz[|s1|][|s2|] que representa o número de similaridades entre a primeira e a segunda seqüências de
DNA. (matriz de inteiros)
b: custo do buraco vazio (inteiro)
c: Custo de tipos iguais (inteiro)
d: Custo de tipos diferentes (inteiro)
p: número de processadores
k, r, s, i, j, m, n, valor1, valor2, valor3: inteiros
CGM/BSP()
- Supomos |s1| = m e |s2| = n.
para k = 1 a p faça
se i = 1 então
para r = ((k-1)*m/p)+1 a k*m/p e s = 1 a n/p faça
a[i,j] = maximo(a[i-1,j] + b,
a[i-1,j-1] + pontuação(i,j),
a[i,j-1] + b)
enviar (Matriz k de i, processador i+1);
se i != 0 então
receber (Matriz k de i-1, processador p-1);
para r = ((k-1)*m/p)+1 a k*m/p e s= 1 a n/p faça
a[i,j] = maximo(a[i-1,j] + b,
a[i-1,j-1] + pontuação(i,j),
a[i,j-1] + b)
se i != p então
enviar(Matriz k de i, processador i+1);
pontuação(i,j)
se s1[i] = s2[j] então
retorna c
senão
retorna d
maximo(valor1, valor2, valor3)
se valor1 > valor2 e valor1 > valor3 então
retorna valor1
senão se valor2 > valor3 então
retorna valor2
senão
retorna valor3
42

43. Capítulo 4
Neste capítulo será apresentada a
documentação do projeto. Assim sendo,
através deste conteúdo pretende-se
passar uma visão clara e objetiva da
proposta e do funcionamento do cluster
para processamento de comparação de
seqüências de DNA utilizando algoritmos
computacionais paralelizáveis.
43

44. Especificações do projeto
Este capítulo tratará de toda a especificação e o desenvolvimento do projeto.
Sendo assim, antes de começar a documentação UML, serão introduzidos alguns
conceitos abordados nesse projeto em conjunto com suas especificações.
Conceitualização do projeto
Esse projeto tem como objetivo a implementação de um sistema distribuído
clusterizado baseado no algoritmo CGM/BSP, no qual operará através de uma máquina
principal denominada Gerenciador (Manager) ou servidor do sistema. Este gerenciador,
como o próprio nome sugere, gerenciará as requisições de comparação de seqüências
entre os outros nós da rede, também chamados de Executores. Os Executores possuem
uma identificação que lhes é atribuída pelo Gerenciador ao se conectarem ao cluster.
O cluster terá a função de comparar uma determinada seqüência de DNA,
denominada DNA principal, com uma ou mais outras seqüências de DNA, denominadas
de DNA secundário(s). Assim, após concluir a comparação, será gravado o grau de
similaridade entre as seqüências comparadas em um banco de dados para futuras
consultas. Para essa comparação, como visto no capitulo 3, será utilizada uma matriz de
similaridade, a qual indicará o grau de similaridade entre as seqüências.
O sistema possuirá apenas uma máquina gerenciadora para controle das
requisições de comparação e para o armazenamento do repositório de dados, além de
máquinas Executoras para realizar a comparação.
Sempre que algum Executor for inserido no cluster, ele envia uma solicitação
de inserção ao Gerenciador que verifica a quantidade de executores ativos e retorna ao
Executor o número de registro imediatamente superior ao do último executor pré-
registrado, e este passa a ser o último Executor (a posição de último executor é
importante para a propagação de requisições de configuração e comparação, como será
descrito posteriormente neste capítulo).
Ao receber alguma solicitação para comparação de similaridade entre duas
seqüências de DNA, o Gerenciador envia a identificação (ID) de cada uma das
seqüências de DNA junto aos parâmetros de ponderação (pesos para bases iguais, bases
diferentes e inserção de lacunas) ao último Executor, e este envia solicitação ao Executor
imediatamente anterior e assim sucessivamente em cascata, até o Executor 0. O
Executor 0, ao receber a solicitação, inicializa a comparação e envia sua resposta ao
Executor imediatamente superior, que também compara e envia sua resposta. Essa
seqüência de ações cascateadas ocorrerão até o cálculo completo das seqüências de
DNAs. Ao terminar de processar a comparação, o último Executor envia a resposta da
comparação ao Gerenciador que se encarrega de gravá-la no repositório de dados.
Modularização e divisão de responsabilidades
Essa sessão descreverá os módulos existentes no projeto, assim as iterações
que eles realizam com os outros módulos do sistema. O projeto do cluster foi dividido em
quatro grandes módulos, que serão chamados aqui de Interface Web, Gerenciador,
Executor, e ClusterKnoppix. Cada módulo será tratado de forma separada e exclusiva,
44

45. após a descrição de todos os módulos, será mostrada a integração entre eles.
Módulo Interface Web
Este módulo tratará da interface com o usuário, além de possuir ferramentas
para a manipulação de dados no repositório de dados. Suas principais funcionalidades
são:
Manipulação de inserção, modificação e remoção de registros de
seqüências de DNA no repositório de dados.
Tela para listagem das seqüências que já foram comparadas.
Tela para listagem das seqüências que ainda não foram comparadas, com
a possibilidade envio de requisição para comparação.
Na tela de listagem das seqüências comparadas, ao escolher uma seqüência
de DNA (o DNA principal), haverá uma lista que exibirá todas as outras seqüências de
DNAs (DNAs secundários) que já foram comparadas com o DNA escolhido. Nesta lista
também será exibida a pontuação e o valor dos pesos de bases e lacuna escolhidos.
Na tela de listagem das seqüências que ainda não foram comparadas, ao
escolher uma seqüência de DNA (o DNA principal), uma lista exibirá todas as outras
seqüências de DNA que ainda não foram comparadas com o DNA escolhido. Nessa tela
haverá um botão para o envio de solicitações de comparação (esse botão é uma interface
applet que enviará as solicitações ao Gerenciador).
O módulo de Interface Web será implementado em PHP sendo executado em
um servidor Apache instalado na mesma máquina do repositório de dados, porém, há
possibilidade de instalá-lo em qualquer outra máquina que tenha serviço de servidor de
Web com suporte a PHP e Java (caso precise executar o applet).
Módulo Gerenciador
Este módulo é o responsável pelo controle inserções de Executores no
cluster, pelo controle de pedidos de comparação de DNAs e pela gravação dos resultados
dessas comparações no repositório de dados.
Ao receber o endereço IP de um Executor solicitando registro no cluster, o
Gerenciador verifica na lista de Executores válidos o números dos executores registrados
e retorna ao Executor solicitante um número imediatamente posterior ao número do último
executor registrado. Após isso, o Gerenciador insere o IP e o número do novo Executor
na lista de Executores e o Executor se registra no RMIRegistry com o número recebido.
Ao receber algum pedido de comparação de DNA, o Gerenciador o insere em
uma fila de requisições. Caso os Executores não estejam comparando nenhuma outra
requisição, o Gerenciador envia a requisição ao último Executor da lista de executores
para começar a comparação. Ao terminar a comparação, o Gerenciador recebe a
resposta do último Executor, remove a requisição da fila de requisições e grava o valor da
comparação e dos pesos no repositório de dados.
Módulo Executor
Este módulo é o responsável pela execução do algoritmo CGM/BSP para o
45