Jean Rodrigo dos Santos
                  Rafael Caetano Pinto
           Valdemárcio Fernandes dos Santos




           ...
Jean Rodrigo dos Santos
                  Rafael Caetano Pinto
           Valdemárcio Fernandes dos Santos




           ...
Persevera na tua determinação.




                            3
Agradecemos às pessoas abaixo que
contribuíram para a conclusão desse projeto:

Antonio Fernando Nunes Guardado,

Celso Si...
Resumo
           Esse projeto visa a construção e a configuração de um Sistema Distribuído
aplicado para a comparação de ...
Abstract
            This project aims the construction and the configuration of a Distributed
System suitable for a DNA s...
Sumário
                                                                                                                  ...
Algoritmo para validação de sequências de DNA ....................................................... 38
     Similaridade...
Domínios ....................................................................................................................
Capítulo 1




      Esse capítulo preza a contextualização do
      projeto,     nele    serão    definidos   a
      jus...
Objetivos

           Elaborar o projeto de um Sistema Distribuído Clusterizado utilizando
algoritmos paralelizáveis exist...
Justificativa

            Em função do crescente desenvolvimento de Sistemas Distribuídos,
impulsionado pela demanda de a...
Metodologia

           Como metodologia abordada, será adotado basicamente o Modelo em Espiral,
também denominado por vár...
Capítulo 2




      Esse capítulo objetiva apresentar a
      introdução conceitual sobre sistemas
      distribuídos, mo...
Introdução a Sistemas Distribuídos

            Neste projeto, a definição de sistema distribuído será uma combinação de
a...
comum) onde cada um deles executa uma aplicação ou parte dela.

            Em um Sistema Centralizado existem limitações ...
em um Sistema Centralizado irão executar na mesma maneira em um Sistema distribuído.
Deve-se verificar se os algoritmos da...
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   M...
bloqueados enquanto o Sistema Operacional envia e recebe uma mensagem. Neste
aspecto, se houver alguma falha, tanto o clie...
na rede pode atingir escala jamais possíveis para Sistema Centralizados. Mesmo fazendo
uso de multiprocessadores e de proc...
Cada elemento possui um ou mais processadores, memória, dispositivos de
entrada/saída e seu próprio Sistema Operacional. E...
Comunicação entre processos no Cluster

            Em um cluster, os nós são independentes, possuindo sua própria memória...
Cluster Homogêneo e Heterogêneo

           Segundo Marcos Pitanga [PIT03], um cluster é homogêneo quando todos os
seus nó...
Tipos de Cluster

           Segundo Deitel [DEI05], há três tipos principais de clusters: cluster de alto
desempenho, de ...
processamento das tarefas enviadas pelo servidor, podendo ou não ter dados ou discos
rígidos. Abaixo segue uma ilustração ...
dependendo da configuração (uso de uma LAN de 12 Gb/s só aumentaria
              o desempenho de aplicações altamente aco...
Invocação Remota de Métodos (RMI)

           A RMI é uma tecnologia desenvolvida pela Sun Microservice, que habilita um
p...
RMI-Registry

           Para tornar o objeto servidor disponível para as chamadas remotas, eles
devem ser registrados no ...
public String getMensagem() throws RemoteException;
     }

OlaImpl.java (implementação do servidor)
     /*
      * Esse ...
Sistema de Arquivo de Rede (NFS              Network File System)

          O sistema de Arquivo de Rede (NFS) é um padrã...
Capítulo 3




      Este capítulo apresenta uma introdução à
      biologia, biologia computacional e aos
      algoritmo...
Biologia Computacional

            Segundo Setúbal [SET94], Biologia Computacional pode ser entendida como
sendo a aplica...
Bacteriófago                    vírus                                              5 x 10 4
Escherichia coli              ...
no final das seqüências.

           Dado um alinhamento entre duas seqüências, podemos atribuir uma
pontuação, esta pontu...
que possam ser consultados rapidamente como mostrado na figura 3.2.1.

                                          AAA
     ...
A       G             C


                            0              -2       -4            -6



                        ...
entre :
            (i-1,j) + b, ou seja, o valor da célula à esquerda mais b (onde valor de b é -2)
            (i-1,j-1)...
Algoritmo para validação de seqüências de DNA
Descrição:             Verifica se a sequência de DNA é uma sequência válida...
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 cal...
Algoritmos de alinhamento e similaridade utilizados
como base neste projeto

Algoritmo básico do método alignment() da cla...
Algoritmo básico do método similarity() da classe DNA
Descrição:             Gera a pontuação de um alinhamento ótimo em m...
Algoritmo básico do método CGM/BSP() da classe DNA
Descrição:             Gera a pontuação de um alinhamento ótimo de form...
Capítulo 4




      Neste capítulo será apresentada a
      documentação do projeto. Assim sendo,
      através deste con...
Especificações do projeto

           Este capítulo tratará de toda a especificação e o desenvolvimento do projeto.
Sendo ...
após a descrição de todos os módulos, será mostrada a integração entre eles.

Módulo Interface Web

          Este módulo ...
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Tcc Bio Cluster
Próximos SlideShares
Carregando em…5
×

Tcc Bio Cluster

3.735 visualizações

Publicada em

Tcc Biocluster java

Publicada em: Educação, Tecnologia
0 comentários
0 gostaram
Estatísticas
Notas
  • Seja o primeiro a comentar

  • Seja a primeira pessoa a gostar disto

Sem downloads
Visualizações
Visualizações totais
3.735
No SlideShare
0
A partir de incorporações
0
Número de incorporações
4
Ações
Compartilhamentos
0
Downloads
104
Comentários
0
Gostaram
0
Incorporações 0
Nenhuma incorporação

Nenhuma nota no slide

Tcc Bio Cluster

  1. 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. 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. 3. Persevera na tua determinação. 3
  4. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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

×