UMA ABORDAGEM EM HARDWARE PARA ... - Bioserver

UMA ABORDAGEM EM HARDWARE PARA
ALGORITMOS DE COMPARAÇÃO DE SEQÜÊNCIAS
BASEADOS EM PROGRAMAÇÃO DINÂMICA
LUÍS GUSTAVO DE AQUINO CARVALHO
DISSERTAÇÃO DE MESTRADO EM CIÊNCIA DA COMPUTAÇÃO
DEPARTAMENTO DE CIÊNCIA DA COMPUTAÇÃO

UNIVERSIDADE DE BRASÍLIA
INSTITUTO DE CIÊNCIAS EXATAS
DEPARTAMENTO DE CIÊNCIA DA COMPUTAÇÃO
UMA ABORDAGEM EM HARDWARE PARA
ALGORITMOS DE COMPARAÇÃO DE SEQÜÊNCIAS
BASEADOS EM PROGRAMAÇÃO DINÂMICA
LUÍS GUSTAVO DE AQUINO CARVALHO
ORIENTADOR: PROF. DR. RICARDO PEZZUOL JACOBI
DISSERTAÇÃO DE MESTRADO EM
CIÊNCIA DA COMPUTAÇÃO
PUBLICAÇÃO: XXX/2003
BRASÍLIA/DF, DEZEMBRO/2003.

UNIVERSIDADE DE BRASÍLIA
INSTITUTO DE CIÊNCIAS EXATAS
DEPARTAMENTO DE CIÊNCIA DA COMPUTAÇÃO
UMA ABORDAGEM EM HARDWARE PARA
ALGORITMOS DE COMPARAÇÃO DE SEQÜÊNCIAS
BASEADOS EM PROGRAMAÇÃO DINÂMICA
LUÍS GUSTAVO DE AQUINO CARVALHO
DISSERTAÇÃO DE MESTRADO SUBMETIDA AO DEPARTAMENTO DE CIÊNCIA
DA COMPUTAÇÃO DO INSTITUTO DE CIÊNCIAS EXATAS DA UNIVERSIDADE
DE BRASÍLIA, COMO PARTE DOS REQUISITOS NECESSÁRIOS PARA A OBTEN-
ÇÃO DO GRAU DE MESTRE.
APROVADA POR:
PROF. DR. RICARDO PEZZUOL JACOBI (UnB)
(ORIENTADOR)
PROF a DR a MARIA EMÍLIA MACHADO TELLES WALTER (UnB)
(EXAMINADOR INTERNO)
PROF. DR. JOSÉ CAMARGO DA COSTA (UnB)
(EXAMINADOR EXTERNO)
BRASÍLIA/DF, 17 DE DEZEMBRO DE 2003.
ii

FICHA CATALOGRÁFICA
CARVALHO, LUÍS GUSTAVO DE AQUINO
Uma Abordagem em Hardware para Algoritmos de Comparação de Seqüências
Baseados em Programação Dinâmica [Distrito Federal] 2003.
xiv, 100 p., 297mm (CIC/IE/UnB, Mestre, Ciência da Computação, 2003).
Dissertação de Mestrado — Universidade de Brasília. Instituto de Ciências
Exatas. Departamento de Ciência da Computação.
1. Comparação de seqüências 2. Smith-Waterman
3. Arquiteturas Reconfiguráveis 4. FPGA
5. Arquiteturas Sistólicas
I. CIC/IE/UnB II. Título (série)
REFERÊNCIA BIBLIOGRÁFICA
CARVALHO, L. G. A. (2003). Uma Abordagem em Hardware para Algoritmos de
Comparação de Seqüências Baseados em Programação Dinâmica. Dissertação de Mestrado,
Publicação XXX/2003, Departamento de Ciência da Computação, Universidade de
Brasília, Brasília, DF, 100 p.
CESSÃO DE DIREITOS
NOME DO AUTOR: Luís Gustavo de Aquino Carvalho
TÍTULO DA DISSERTAÇÃO DE MESTRADO: Uma Abordagem em Hardware para
Algoritmos de Comparação de Seqüências Baseados em Programação Dinâmica.
GRAU / ANO: Mestre / 2003
É concedida à Universidade de Brasília permissão para reproduzir cópias desta dissertação
de mestrado e para emprestar ou vender tais cópias somente para propósitos acadêmicos e
científicos. O autor reserva outros direitos de publicação e nenhuma parte desta dissertação
de mestrado pode ser reproduzida sem a autorização por escrito do autor.
Luís Gustavo de Aquino Carvalho
iii

iv
A minha família.

Agradecimentos
Aos meus pais, pela formação que me foi dada e por todo o amor recebido.
Ao meu orientador, Prof. Ricardo Jacobi, por sua paciência, compreensão
e excelência acadêmica.
Aos meus amigos, em especial ao Antônio Marcelo que me apresentou ao
meu orientador e me incentivou a trabalhar com arquiteturas reconfiguráveis;
à Marie, pela grande ajuda durante a conclusão das disciplinas, além de grande
companheira; à Márcia, pela sua prontidão em elucidar dúvidas; ao Hugo e
Cristiano, pelas constantes trocas de idéias e pela valiosa ajuda na formatação
em L A TEX desta dissertação.
E principalmente à minha esposa e filhos, por todos os momentos que deixei
de estar com eles para me dedicar à essa dissertação.
v

UMA ABORDAGEM EM HARDWARE PARA
ALGORITMOS DE COMPARAÇÃO DE SEQÜÊNCIAS
BASEADOS EM PROGRAMAÇÃO DINÂMICA
Resumo
Pesquisas em bancos de dados biológicos utilizam algoritmos de comparação
de seqüências para busca de similaridades entre as seqüências armazenadas
nestes bancos e a seqüência consultada. Embora os algoritmos de comparação
baseados em programação dinâmica retornem uma resposta ótima, eles não
são usados na prática dos laboratórios de Bioinformática, pois a complexidade
quadrática de tempo é um fator limitante em virtude do considerável tamanho
das seqüências biológicas.
Métodos mais rápidos, baseados em probabilidades, mas sem garantia de
exatidão, são preferidos por possuírem uma complexidade linear de tempo.
Assim, a aplicação de técnicas que acelerem e viabilizem a utilização dos
algoritmos baseados em programação dinâmica constitui uma importante contribuição
para a qualidade da informação produzida.
Dentre essas técnicas está a criação de um hardware dedicado para uma
aplicação específica. Nesse escopo, os sistemas reconfiguráveis baseados em
FPGA’s encontram grande aplicação, pois permitem a prototipação em hardware
de algoritmos bastante complexos com baixos custos.
Este trabalho propõe e implementa em FPGA um hardware baseado em
uma arquitetura sistólica que lineariza o tempo de execução dos algoritmos
baseados em programação dinâmica.
A fim de validar os resultados obtidos foram realizadas comparações com
outras implementações seqüenciais e paralelas desses algoritmos.
vi

A HARDWARE APPROACH
TO SEQUENCE COMPARISON ALGORITHMS
BASED ON DYNAMIC PROGRAMMING
Abstract
Sequence comparison algorithms are used in biological database searches
in order to find similarities between the database sequences and a query sequence.
Although the comparison algorithms based on dynamic programming
techniques produces an optimal result, they are not used by Bioinformatics
laboratories, once its quadratic time complexity is prohibitive in view of the
considerable size of the biological sequences.
Faster methods, based on probabilities, but without precision guarantee,
are preferred for its linear time complexity.
Therefore, improving sequence comparison algorithms based on dynamic
programming constitutes an important contribution to the quality of the information
produced.
A dedicated hardware for an specific application could be one of this solutions.
In this scope, reconfigurable systems find enormous application because
they provide rapid prototyping of complex algorithms with small costs.
In this work, we propose and implement in FPGA a systolic architecture
based hardware which turns to linear the time complexity of the comparison
algorithms based on dynamic programming.
In order to validate the results produced by our implementation, we compared
our results with the ones produced by other sequential and parallel
implementations of the same algorithm.
vii

Sumário
1 INTRODUÇÃO 1
1.1 Escopo do Trabalho . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.1.1 Projeto Genoma Humano . . . . . . . . . . . . . . . . . . . . . . . 1
1.1.2 Pesquisas no Brasil . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.1.3 Bioinformática e Biologia Computacional . . . . . . . . . . . . . . . 4
1.1.4 Pesquisas em Bancos de Dados Biológicos . . . . . . . . . . . . . . 5
1.1.5 Algoritmos para Comparação de Seqüências . . . . . . . . . . . . . 6
1.2 Revisão Bibliográfica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.3 Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.4 Organização da Dissertação . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2 FUNDAMENTAÇÃO TEÓRICA 11
2.1 Biologia Molecular . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.1.1 Ácidos Nucléicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.1.1.1 DNA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.1.1.2 RNA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.1.2 Aminoácidos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.1.3 Proteínas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.1.4 Genes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.1.5 Genética Molecular . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.1.6 Síntese Protéica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.2 Algoritmos para Comparação de Seqüências Baseados em Programação
Dinâmica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
viii

2.2.1 Alinhamento de seqüências . . . . . . . . . . . . . . . . . . . . . . . 22
2.2.2 Algoritmos baseados em programação dinâmica . . . . . . . . . . . 24
2.2.2.1 Comparação global . . . . . . . . . . . . . . . . . . . . . . 24
2.2.2.2 Comparação local . . . . . . . . . . . . . . . . . . . . . . . 27
3 HARDWARE 30
3.1 Sistemas Dedicados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
3.2 Arquiteturas Sistólicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.3 Sistemas Reconfiguráveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.3.1 FPGA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.3.2 Síntese de sistemas reconfiguráveis . . . . . . . . . . . . . . . . . . 39
3.3.3 Linguagens de descrição de hardware e VHDL . . . . . . . . . . . . 41
3.4 Somadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
3.4.1 Meio-somador (half adder) . . . . . . . . . . . . . . . . . . . . . . . 44
3.4.2 Somador completo (full adder) . . . . . . . . . . . . . . . . . . . . 45
3.4.3 Somador ripple carry . . . . . . . . . . . . . . . . . . . . . . . . . . 45
3.4.4 Somador com “vai-um” antecipado (carry look ahead) . . . . . . . . 46
3.4.5 Subtrator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
3.5 Matrizes esparsas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
3.5.1 Compressed Row Storage (CRS) . . . . . . . . . . . . . . . . . . . . 49
3.5.2 Compressed Column Storage (CCS) . . . . . . . . . . . . . . . . . . 50
3.5.3 Compressed Diagonal Storage (CDS) . . . . . . . . . . . . . . . . . 50
3.5.4 Jagged Diagonal Storage (JDS) . . . . . . . . . . . . . . . . . . . . 51
4 DESCRIÇÃO DA IMPLEMENTAÇÃO 52
4.1 Aplicação de Estruturas Paralelas na comparação de seqüências . . . . . . 52
4.2 Dependência de Dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
4.3 Plataforma Utilizada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
4.4 Descrição Geral . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
4.4.1 Estrutura sistólica . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
ix

4.4.2 Otimização de Utilização de Espaço e Armazenamento dos Alinhamentos
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
4.4.3 Outras otimizações . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
5 RESULTADOS 72
5.1 Validação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
5.2 Desempenho . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
6 CONCLUSÕES 81
x

Lista de Tabelas
1.1 Projetos Regionais de Seqüenciamento no Brasil. . . . . . . . . . . . . . . . 4
2.1 Principais diferenças entre o DNA e o RNA. . . . . . . . . . . . . . . . . . 15
2.2 Os 20 diferentes tipos de aminoácidos encontrados na natureza. . . . . . . 17
3.1 Tabela-verdade do meio-somador (half adder). . . . . . . . . . . . . . . . . 44
3.2 Tabela-verdade do somador completo (full adder). . . . . . . . . . . . . . . 45
5.1 Quantidade de elementos lógicos utilizados e freqüência máxima de operação
para diferentes comprimentos do vetor sistólico. . . . . . . . . . . . . . . . 77
5.2 Comparação de velocidade entre uma implementação seqüencial, diversas
paralelas e em hardware do algoritmo baseado em programação dinâmica. . 80
xi

Lista de Figuras
1.1 Crescimento do GenBank. . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.2 Mapeamento do cálculo da matriz de similaridade em uma estrutura sistólica
bidirecional. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.1 Bases Nitrogenadas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.2 Tipos de Açúcares. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.3 A estrutura de uma molécula de DNA, formada por uma dupla fita. (a)
Forma helicoidal da dupla cadeia. (b) Forma esquemática da dupla cadeia,
onde podemos visualizar a ligação entre as moléculas de açúcar (S)
e de fosfato (P), em cada uma das fitas, e o emparelhamento das bases
Adenina/Timina e Citosina/Guanina, entre as duas fitas. . . . . . . . . . . 13
2.4 Dupla fita de DNA, observando-se o pareamento das bases A-T e C-G. . . 14
2.5 Exemplo de alguns grupos orgânicos. . . . . . . . . . . . . . . . . . . . . . 15
2.6 Estrutura e exemplos de alguns aminoácidos. . . . . . . . . . . . . . . . . . 16
2.7 União de dois aminoácidos por uma ligação peptídica. . . . . . . . . . . . . 16
2.8 Visão esquemática dos genes, cromossomos e genoma. . . . . . . . . . . . . 19
2.9 Código genético. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.10 Duplicação do DNA. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.11 Representação esquemática da transcrição e tradução. . . . . . . . . . . . . 21
2.12 Detalhamento do processo de tradução. . . . . . . . . . . . . . . . . . . . . 21
2.13 Pontuação de um possível alinhamento entre CCTAGA e CTATGCAC. . . 23
2.14 Matriz de similaridades das seqüências x = AACGT e y = AGC. . . . . . 26
2.15 Obtenção do melhor alinhamento global. . . . . . . . . . . . . . . . . . . . 27
3.1 Aspecto geral de uma arquitetura sistólica. . . . . . . . . . . . . . . . . . . 33
3.2 Alguns tipos de estruturas sistólicas. . . . . . . . . . . . . . . . . . . . . . 34
3.3 Modelos segundo a classificação de Page. . . . . . . . . . . . . . . . . . . . 37
xii

3.4 Estrutura interna de um FPGA. . . . . . . . . . . . . . . . . . . . . . . . . 39
3.5 Fluxo de projeto utilizando FPGAs. . . . . . . . . . . . . . . . . . . . . . . 40
3.6 Diagrama esquemático do meio-somador. . . . . . . . . . . . . . . . . . . . 45
3.7 Diagrama esquemático do somador completo. . . . . . . . . . . . . . . . . 46
3.8 Diagrama de um somador ripple carry de 4 bits. . . . . . . . . . . . . . . . 46
3.9 Diagrama de um somador de 4 bits com “vai-um” antecipado. . . . . . . . 47
3.10 Diagrama de um somador de 16 bits com “vai-um” antecipado. . . . . . . . 48
3.11 Diagrama de um somador-subtrator de 4 bits. . . . . . . . . . . . . . . . . 48
4.1 Paralelização do cálculo da matriz de similaridade. . . . . . . . . . . . . . . 53
4.2 Matriz de similaridade para as seqüências ACATAGGCAT e CATAAGGCT. 54
4.3 Tipos de emulação da matriz de similaridade. . . . . . . . . . . . . . . . . 55
4.4 Estrutura linear sistólica uniderecional. . . . . . . . . . . . . . . . . . . . . 56
4.5 Estrutura interna inicial do elemento de processamento. . . . . . . . . . . . 57
4.6 Fluxo interno dos dados dentro do elemento de processamento. . . . . . . . 58
4.7 Dinâmica do sistema para vários elementos de processamento. . . . . . . . 58
4.8 Somador de 8 bits com a constante -2 embutida no mesmo. . . . . . . . . . 60
4.9 Cálculo do valor da diagonal. . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.10 Cálculo do valor relativo à inserção do espaço. . . . . . . . . . . . . . . . . 61
4.11 Codificação dos vetores da matriz de similaridade. . . . . . . . . . . . . . . 63
4.12 Tipos de zeros existentes na matriz de similaridade. . . . . . . . . . . . . . 67
4.13 Verificação antecipada para saber se o zero fará parte de uma seqüência. . 68
4.14 Posição das bases para a verificação antecipada. . . . . . . . . . . . . . . . 69
4.15 Novo formato do dado fornecido à memória externa. . . . . . . . . . . . . . 70
5.1 Matrizes de similaridade para as seqüências CATAG e ATAGC e para CA-
TAG e CATGA. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
5.2 Comparação entre as seqüências CATAG e ATAGC. . . . . . . . . . . . . . 73
5.3 Comparação entre as seqüências CATAG e CATGA. . . . . . . . . . . . . . 75
5.4 Comparação entre as seqüências ACATAGGCAT e CATAAGGCT. . . . . 76
5.5 Freqüência máxima de operação x Quantidade de células do vetor. . . . . . 78
xiii

5.6 Quantidade de elementos lógicos utilizados no FPGA x Quantidade de
células do vetor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
xiv

Capítulo 1
INTRODUÇÃO
1.1 Escopo do Trabalho
Há 50 anos, no dia 7 de março de 1953, no laboratório Cavendish, na Inglaterra, Francis
Crick e James Watson concluíram que a molécula do DNA tem a estrutura de uma dupla
hélice, uma descoberta que daria novos rumos à ciência. No dia 25 de abril daquele
ano, a revista Nature publicou o artigo Molecular Structure of Nucleic Acids (Estrutura
Molecular dos Ácidos Nucleicos) [72], primeiro de uma série sobre o tema. Com menos de
mil palavras e um gráfico simplificado, o trabalho descrevia a estrutura da molécula.
A partir de então, a Biologia Molecular tornou-se, de fato, uma ciência. Incontáveis
pesquisas começaram a serem feitas para melhor compreender a estrutura e o funcionamento
da genética dos seres vivos. Essas pesquisas proporcionaram inúmeros avanços nas
técnicas da Biologia Molecular que aceleraram o processo de descoberta e descrição da
estrutura e funcionalidade dos genes. Entre os avanços, o aparecimento de seqüenciadores
automáticos capazes de gerar dados genômicos em grande escala e de ferramentas
de análise computacional comparativa entre seqüências trouxeram um grande progresso
nessa nova área do conhecimento biológico.
1.1.1 Projeto Genoma Humano
Um importante marco para o atual desenvolvimento da Biologia Molecular foi o Projeto
Genoma Humano, um empreendimento internacional iniciado formalmente em 1990 e
projetado para durar 15 anos, com os seguintes objetivos:
• Identificar e fazer o mapeamento dos 80 mil genes que se calculava existirem no
DNA das células do corpo humano;
• Determinar as seqüências dos 3 bilhões de bases químicas que compõem o DNA
humano;
• Armazenar essas informações em bancos de dados, desenvolver ferramentas eficientes
para analisar esses dados e torná-los acessíveis para novas pesquisas biológicas.
1

Como parte deste empreendimento, paralelamente foram desenvolvidos estudos com
outros organismos selecionados, principalmente microorganismos considerados modelos
biológicos, tais como Saccharomyces cerevisiae e Drosophila melanogaster, entre outros.
O objetivo era desenvolver e aperfeiçoar novas técnicas de análise e também auxiliar o
trabalho de interpretar a complexa função genética humana. Como existe uma ordem
subjacente a toda a diversidade da vida e como todos os organismos se relacionam através
de semelhanças em suas seqüências de DNA, o conhecimento adquirido a partir de genomas
não-humanos levaria a novas descobertas na biologia humana.
Em 1990, ao iniciar-se o PGH, apenas 4550 genes humanos haviam sido identificados;
cerca de 1500 genes haviam sido associados a localizações específicas nos 46 cromossomos, e
apenas algumas, dentre cerca de 4000 doenças genéticas existentes, haviam sido entendidas
em um nível molecular.
Em 12 de fevereiro de 2001, simultaneamente ao anúncio da empresa norte-americana
Celera, o PGH anunciou as primeiras transcrições quase completas do código genético
humano. O número de genes existentes, segundo os cálculos de ambas as equipes de
pesquisadores, não chega a 40 mil. Os resultados foram publicados em duas revistas
diferentes. A revista inglesa Nature [3] publicou o trabalho dos pesquisadores do PGH,
liderados por Francis Collins, e a norte-americana Science, o dos pesquisadores da Celera,
liderados pelo empresário-cientista Craig Venter.
Em 14 de abril de 2003, o consórcio internacional que constituiu o Projeto Genoma
Humano anunciou oficialmente a conclusão do seqüenciamento dos 3 bilhões de bases
do DNA da espécie humana. Liderados pelo Instituto Nacional de Pesquisa do Genoma
Humano (NHGRI), nos EUA e pelo Instituto Sanger, no Reino Unido, o projeto durou
13 anos e, segundo se afirmou, consumiu 2,7 bilhões de dólares para se chegar à meta
proposta em 1990, de decifrar a estrutura do DNA humano com 99,9% de precisão.
Embora o resultado desse grandioso empreendimento mundial deva ser comemorado,
ele é apenas a conclusão da etapa inicial das pesquisas sobre o assunto. A analogia que
se faz é a seguinte: os bilhões de elementos que estão sendo decifrados nada mais são do
que as “letras”. Depois será preciso entender as “palavras” (mapeamento dos genes) e a
“linguagem”, que correspondem às funções que esses genes desempenham.
Essa linguagem contida na molécula de DNA serve para ordenar a fabricação das
proteínas, que são usadas pelos seres vivos - das bactérias aos humanos - para executar
tarefas vitais como movimentar-se, respirar, pensar e gastar energia.
O objetivo agora, depois de se conhecer o genoma humano completo, assim como o de
outros organismos, é determinar a composição, estrutura, e funções de todas as proteínas
do corpo para saber como elas interagem entre si. Ao conjunto de proteínas que intervêm
nos processos biológicos de uma espécie é dado o nome de proteoma.
Empresas e laboratórios públicos e privados já estão na corrida para entender o proteoma,
embora este seja sem dúvida muito mais extenso e complicado que o genoma.
2

Enquanto o DNA possui somente quatro bases nitrogenadas, as proteínas são compostas
de aminoácidos, dos quais existem 20 tipos diferentes. Além disso, o DNA está localizado
no núcleo de qualquer célula, o que facilita a sua obtenção e purificação, já muitas
proteínas só estão presentes em alguns tipos de células, e somente em certas fases de seu
desenvolvimento.
Por último, não basta enumerar a seqüência de aminoácidos que forma a proteína,
porque tão importante quanto a seqüência é a estrutura tridimensional que ela possui,
interferindo decisivamente no papel que ela realiza.
Conhecer como funciona o proteoma é um processo complexo, porque na maioria das
vezes a proteína não age sozinha realizando determinada tarefa, mas sim é uma interação
entre elas que vai condicionar o processo. Uma forma de conhecer as funções das proteínas,
é compará-la a funções conhecidas, tanto na própria espécie, quanto em outras, já que a
maior parte das proteínas se conservam em muitos organismos, mesmo que alguns se
encontrem filogeneticamente distantes entre si.
A corrida ao grande mapa das proteínas, ou proteoma, será um dos maiores desafios
científicos da próxima década.
1.1.2 Pesquisas no Brasil
A participação do Brasil na área de pesquisas genômicas teve início em 1998 a partir
do financiamento, pela FAPESP (Fundação de Amparo à Pesquisa do Estado de São
Paulo), de um instituto virtual formado por um consórcio de laboratórios, responsável
pelo seqüenciamento e análise de nucleotídeos, denominado ONSA (Organization for Nucleotide
Sequencing and Analysis) [53]. O primeiro resultado importante desse instituto
com reconhecimento internacional ocorreu em 2000 com a publicação do genoma do fitopatógeno
Xylella fastidiosa [65], agente etiológico da Citrus Variegated Chlorosis (CVC),
mais conhecida como praga do amarelinho. Essa doença destrói lavouras de laranja,
principalmente no Estado de São Paulo, ocasionando prejuízos econômicos de grandes
proporções.
Motivada pelo sucesso alcançado, a FAPESP resolveu investir em projetos mais ambiciosos,
como o do mapeamento do genoma da cana-de-açúcar, do câncer humano (em
colaboração com o Instituto Ludwig para Pesquisa do Câncer), do café e também de vários
organismos e pragas como o Xylella fastidiosa de videira, o Xanthomonas campestris, o
Xanthomonas axonopodis e o Leifsonia xyli, além de subsidiar outros projetos como o
do mapeamento do genoma funcional do Schistosoma mansoni. Outro ponto que merece
destaque é a criação das redes de seqüenciamento, que ocorreu tanto no âmbito nacional
como no regional. No âmbito nacional há dois projetos: o Projeto Genoma Brasileiro,
que seqüenciou a bactéria Chromobacterium violaceum, cujos resultados podem ser potencialmente
aplicados no controle da doença de chagas e da leishmaniose, e o Projeto
Genolyptus, responsável pelo seqüenciamento do eucalipto (Fundo Verde-Amarelo/MCT).
3

No âmbito regional surgiram várias redes com projetos de seqüenciamento de organismos
importantes, especialmente para o controle de pragas e doenças, conforme indicado na
tabela 1.1.
Tabela 1.1: Projetos Regionais de Seqüenciamento no Brasil.
Rede Regional
Organismo Alvo
Rede Genoma do Estado de Minas Gerais
Schistosoma mansoni
Rede Genoma Nordeste
Leishmania chagasi
Rede Genômica do Estado da Bahia e São Paulo Crinipellis perniciosa
Rede Genoma do Consórcio
do Instituto de Biologia Molecular do Paraná, Trypanossoma cruzi
FIO-CRUZ e Universidade de Mogi das Cruzes
Programa Genoma do Estado do Paraná
Herbaspirillum seropedicae
Rede Genoma do Rio de Janeiro
Gluconacetobacter diazotrophicus
Rede Sul de Análise de Genomas e Biologia Estrutural Mycoplasma hyopneumoniae
Rede Genoma Centro-Oeste
Paracoccidioides brasiliensis
Esses projetos colocam o Brasil no grupo dos países com tecnologia e infra-estrutura
suficientes para conduzirem pesquisas na área genômica. Isso é de importância estratégica
vital, pois permite que problemas específicos do nosso país, que afetam nossa população
e/ou produção agropecuária, sejam resolvidos sem depender dos laboratórios estrangeiros.
Além disso, esses projetos estimulam o desenvolvimento de novas tecnologias e a capacitação
e de profissionais especializados, o que contribui para colocar o Brasil em posição
de igualdade perante a comunidade científica internacional nessa área.
1.1.3 Bioinformática e Biologia Computacional
O Projeto Genoma Humano e os crescentes avanços da tecnologia tem permitido aos
laboratórios de Biologia Molecular fornecerem detalhes cada vez mais precisos sobre as
estruturas estudadas. O enorme volume de informações acumulado desde então e a necessidade
de trabalhar esses dados eficientemente criou uma série de problemas que são, por
natureza, interdisciplinares. Em particular, as teorias da matemática e da computação
tornaram-se fundamentais no processo de manipulação de dados científicos dentro da Biologia
Molecular [64].
Isso levou ao surgimento de duas áreas de pesquisa intimamente ligadas:
• A Bioinformática, que tem como finalidade principal gerar novos conhecimentos a
partir da grande quantidade de dados que vêm sendo obtidos sobre seqüências de
DNA e proteínas e pode ser descrita como a aquisição, organização, armazenamento
e análise dessas informações biológicas;
• e a Biologia Computacional, que estuda o desenvolvimento de algoritmos e programas
computacionais para auxiliar a Bioinformática.
4

A Bioinformática, apesar de ser um campo relativamente novo, tem evoluído dramaticamente
nos últimos anos e, hoje, é fundamental para as pesquisas realizadas em Biologia
Molecular [21].
Há três objetivos principais dentro da Bioinformática. O primeiro é prover um meio de
organizar os dados biológicos de forma a tornar fácil o acesso às informações e a submissão
de novos dados à medida que estes são gerados. Diversos bancos de dados biológicos foram
e continuam sendo criados com esse objetivo. O segundo objetivo é o desenvolvimento
de ferramentas para processar os dados armazenados e extrair diversas informações ali
contidas. O terceiro objetivo é a análise dos resultados gerados por essas ferramentas
para interpretar as informações de uma maneira que seja biologicamente consistente e
relevante [44].
1.1.4 Pesquisas em Bancos de Dados Biológicos
Tradicionalmente, pesquisas em Biologia investigavam um sistema isoladamente e o
comparavam com outros poucos sistemas relacionados. A Bioinformática permitiu conduzir
análises globais envolvendo um volume muito maior de dados, de forma a descobrir
princípios comuns e características importantes mais facilmente.
Um dos problemas fundamentais nessa área é a comparação entre duas ou mais seqüências
de DNA ou proteínas, servindo como base para a solução de uma grande variedade de
problemas. A comparação entre seqüências é uma tarefa computacionalmente intensa e
lenta. Primeiro, porque os algoritmos utilizados possuem uma complexidade de tempo significativa
pois devem permitir mutações genéticas, ou seja, inserções, remoções ou substituições
nas seqüências comparadas. Segundo, porque o tamanho dessas seqüências podem
ser muito grande, da ordem de milhões de caracteres.
Como os repositórios dessas informações vêm aumentando de tamanho a taxas elevadas,
métodos cada vez mais rápidos e eficientes para a comparação de seqüências se
tornam necessários para se manterem eficientes em relação ao crescente tamanho dos bancos
de dados. Por exemplo, o GenBank, um dos principais bancos de dados públicos
sobre informações genéticas, tem sido alimentado a uma taxa quase exponencial com o
tempo (figura 1.1).
A análise de uma seqüência obtida dentro de um projeto de seqüenciamento é iniciada
comparando-a com as seqüências já descobertas e analisadas, armazenadas nesses bancos
de dados, para que o relacionamento existente entre elas possa permitir estabelecer
a determinação de sua função, estrutura, características evolucionárias e influência em
doenças, entre outras.
5

Figura 1.1: Crescimento do GenBank.
1.1.5 Algoritmos para Comparação de Seqüências
O algoritmo com melhores resultados teóricos foi proposto por Smith e Waterman [66],
baseado em técnicas de programação dinâmica, com o intuito de mostrar as posições
“similares” entre duas seqüências. No entanto, conforme já citado, devido ao considerável
tamanho de algumas seqüências biológicas, a computação por programação dinâmica,
que tem complexidade quadrática de tempo e espaço, torna-se inviável com os recursos
computacionais existentes atualmente.
Assim surgiram os métodos heurísticos de comparação de seqüências, baseados em probabilidades
estatísticas acerca destas seqüências. Estes métodos possuem complexidade
linear de tempo, o que torna as pesquisas mais rápidas, embora não garantam a produção
de resultados ótimos. Apesar desta desvantagem, as ferramentas baseadas nestes métodos
têm sido bem aceitas e amplamente utilizadas pelos laboratórios de seqüenciamento.
Uma das ferramentas mais utilizadas para a comparação de seqüências de DNA com
os bancos de dados genômicos é o BLAST (Basic Local Alignment Search Tool) [6]. O
BLAST é na verdade uma família de ferramentas para análises de DNA e proteínas e não
um único programa.
Uma outra família de ferramentas bastante utilizada, que também utiliza heurísticas,
é o FAST [59], para comparações globais.
Se os algoritmos de comparação baseados em programação puderem ser acelerados de
6

modo a se tornar viável sua utilização, respostas ótimas poderão ser obtidas, uma vez que
as soluções baseadas em heurísticas podem ocultar importantes relacionamentos entre as
seqüências comparadas.
Dentre as alternativas que vêm sendo pesquisadas estão a utilização de técnicas de
computação paralela, que se baseia na cooperação de um conjunto de processadores que
dividem a carga computacional e a construção de hardware específico e dedicado, dessa
forma, mais otimizado e veloz, para a solução desse problema.
Muitos esforços nas áreas comercial e acadêmica já foram feitos para utilizarem hardware
específico com o objetivo de acelerar as pesquisas nos bancos de dados.
Nesta dissertação é proposto um sistema baseado em hardware, chamado de ASIC-
GENE (Acelerador Sistólico para Comparações Genéticas), e que utiliza um dispositivo
reconfigurável conhecido como FPGA. Uma estrutura sistólica linear unidirecional é apresentada
para acelerar o processo da comparação entre seqüências. Essa estrutura possui
inúmeros pequenos processadores dedicados (chamados de elementos de processamento)
que efetuam operações em paralelo, obtendo um significativo ganho de performance em
relação à computação seqüencial.
1.2 Revisão Bibliográfica
Em 1985, Lipton e Lopresti [43] mostraram que o paralelismo existente no algoritmo de
Smith-Waterman poderia ser mapeado em uma estrutura linear sistólica bidirecional. Na
estrutura obtida, cada elemento de processamento (PE) do vetor sistólico era responsável
pelo cálculo de uma das diagonais da matriz de similaridade, com a diagonal principal
sendo processada no centro desse vetor (figura 1.2).
Figura 1.2: Mapeamento do cálculo da matriz de similaridade em uma estrutura sistólica
bidirecional.
As seqüências a serem comparadas entravam em lados opostos do vetor e eram deslocadas
a cada ciclo de relógio de modo a atravessar a estrutura linear. Dessa forma, o
primeiro elemento das duas seqüências se encontravam no centro do vetor, quando era calculado
o primeiro valor da matriz de similaridade. A cada ciclo de relógio, as seqüências
se deslocavam em sentidos opostos e mais valores iam sendo calculados.
7

Se as duas seqüências a serem comparadas possuíssem comprimentos iguais a n e
m, a estrutura linear proposta deveria ter um comprimento de n + m − 1 elementos de
processamento. Entretanto, a complexidade de tempo do algoritmo caiu de O(n × m)
para O(n + m), ou seja, uma complexidade linear.
Para o cálculo de cada elemento da matriz de similaridade, foi sugerido um esquema
de pontuação sem valores negativos e que penalizava mais o alinhamento de caracteres
diferentes das duas seqüências do que o alinhamento de um caracter de uma das duas
seqüências com um espaço (gap). A pontuação proposta seguia a seguinte regra:
t j
. . .
a b
s i . . . c d
⎧
⎪⎨
d = min
⎪⎩
b + 1
c + 1
a se s i = t j
a + 2 se s i ≠ t j
Com esse esquema de pontuação, foi demonstrado que o valor calculado para d seria
igual ao de a ou então igual a a + 2. Com isso, apenas um bit indicaria essa diferença.
Por esse motivo, essa implementação não armazenava os valores calculados da matriz de
similaridade e conforme os dados iam saindo em uma das pontas do vetor, um contador
previamente carregado ia sendo incrementado ou decrementado de acordo com os bits
gerados. No final do processo, o último valor do contador indicava quão próximas eram
as seqüências comparadas. Se o valor fosse baixo, indicava que as seqüências eram bem
parecidas, com um valor igual a zero no caso das seqüências serem idênticas. Valores altos
no contador indicavam que as seqüências eram bem diferentes.
Com essa implementação não era possível obter nenhum alinhamento entre as duas
seqüências e o resultado obtido era meramente um indicador de proximidade entre elas.
Foi observado que os diversos artigos definem dois conceitos: comparação de seqüências
e alinhamento de seqüências. Na comparação, o resultado obtido é simplesmente um
escore que indica se as seqüências comparadas são próximas ou não. No alinhamento é
que se consegue obter quais trechos de uma seqüência são similares ao da outra seqüência
comparada.
Baseadas nessa abordagem, foram propostas várias implementações. Em 1992, Hoang
[31] descreve uma solução bastante similar, utilizando a arquitetura SPLASH [22],
uma matriz lógica linear programável desenvolvida pelo Supercomputer Researh Center
(SRC), que utilizava 32 FPGAs XC3090 da Xilinx [75]. Nessa solução era possível recuperar
pelo menos um alinhamento, embora o esquema de pontuação utilizado foi o proposto
por Lipton e Lopresti.
Em 1993, Hoang [52] sugere uma nova solução utilizando uma arquitetura sistólica
unidirecional, agora baseada no SPLASH 2 [9], uma evolução do sistema anterior. As
duas seqüências eram colocadas em um único vetor e deslocadas para dentro da estrutura
sistólica. Uma marca em cada posição desse vetor indicava quais bases faziam parte da
seqüência de consulta e quais bases eram do banco de dados. Nessa solução, não foram
8

dados detalhes sobre a recuperação de alinhamentos e pela estrutura da célula, apenas o
cálculo de um escore de similaridade (comparação de seqüências) era feito.
Utilizando o acelerador SAMBA [38] (Systolic Accelerator for Molecular Biological
Applications), Lavenier propõe, em 1998, uma nova abordagem para o problema, mas
ainda utilizando uma arquitetura sistólica, pela própria estrutura do SAMBA.
Uma nova implementação da solução de Hoang ocorreu em 2002, utilizando tecnologia
mais moderna, como a família Virtex de FPGAs da Xilinx [25]. A solução de Hoang
também deu origem ao HokieGene [60], um sistema reconfigurável em tempo de execução
baseado na placa Osiris [36] desenvolvida pelo Information Sciences Institute.
Uma solução bastante similar à proposta nessa dissertação foi apresentada por Yamaguchi,
Maruyama e Konagaya [76] em 2002. Nela uma placa PCI contendo uma FPGA
XCV2000E da Xilinx, que contém 43200 células lógicas, foi utilizada, sendo possível a
implementação de 144 elementos de processamento. Cada elemento de processamento
leva quatro ciclos de relógio para gerar seu resultado. Nessa solução não é dito nada sobre
a utilização de uma arquitetura sistólica. A comparação é dividida em vários pedaços
devido às limitações da memória interna da FPGA.
Com algumas modificações, mas ainda baseada na solução de Hoang de 1993, uma nova
proposta é feita por Yu, Kwong, Lee e Leong [78] em 2003. Essa implementação também
utiliza FPGAs da família Virtex da Xilinx, mais especificamente XCV1000E, com 27648
células lógicas.
Algumas soluções utilizando VLSI também foram propostas, como BioScan [73] em
1991, KESTREL [30] em 1996 e as Proclets de Yang [77] em 2002. Essa última utiliza uma
unidade de processamento (chamada de Proclet) para cada célula da matriz de similaridade
e, dessa forma, torna-se muito onerosa, dada as dimensões que a matriz pode atingir.
Dentre as arquiteturas dedicadas, além das já citadas SPLASH, Osiris e SAMBA,
destacam-se o GeneMatcher2 [57] da Paracel [56] que usa um processador ASIC otimizado
para essa tarefa, e o DeCypher [68] da TimeLogic [67] que utiliza FPGAs.
1.3 Objetivos
As soluções analisadas com maior interesse foram as que utilizaram FPGAs. A grande
maioria delas foi baseada nas propostas de Lipton e Lopresti e de Hoang. Nessas abordagens
foi utilizado um esquema de pontuação que, embora simplifique o hardware, penaliza
mais a substituição do que a inserção ou remoção de uma base em uma das seqüências
(ocorrência de espaços). Outro fato observado é que o resultado é simplesmente um escore
que indica a proximidade entre as seqüências comparadas. Quanto menor o escore, maior
a similaridade entre elas.
Nas soluções não baseadas nessas propostas, um hardware dedicado de maior envergadura
foi utilizado como suporte. A exceção é a solução apresentada por Yamaguchi,
9

Maruyama e Konagaya que utilizada placas PCIs de “prateleira”. Entretanto, não são
fornecidos maiores detalhes sobre a implementação feita, de forma que ela pudesse ser
reproduzida.
Dessa forma, até onde se pôde perceber, o trabalho proposto nesta dissertação é inédito,
pois detalha todo o fluxo dos dados dentro da arquitetura sistólica e utiliza um esquema de
pontuação mais voltado para os aspectos biológicos do problema e não com simplificações
do circuito. Além disso, a matriz de similaridade é armazenada e permite a recuperação
de todos os alinhamentos entre as duas seqüências comparadas.
Assim, os objetivos desta dissertação são:
• Propor, implementar e validar uma solução paralela baseada em hardware para o
problema de comparar seqüências utilizando o algoritmo de Smith-Waterman [66];
• Realizar comparações de desempenho com outras implementações do algoritmo,
seqüenciais e paralelas.
1.4 Organização da Dissertação
No capítulo 2 são apresentados os conceitos básicos em Biologia Molecular, sendo
descritos os algoritmos de comparação de seqüências baseados em programação dinâmica.
No capítulo 3, são revistas as arquiteturas sistólicas e as arquiteturas reconfiguráveis, além
de outros conceitos a serem utilizados. A descrição da solução proposta é apresentada no
capítulo 4. Os resultados dos experimentos realizados e análises desses resultados são
apresentados no capítulo 5. Finalmente, no capítulo 6 são apresentadas as conclusões
deste trabalho e propostas novas direções de pesquisa a partir dele.
10

Capítulo 2
FUNDAMENTAÇÃO TEÓRICA
2.1 Biologia Molecular
Um dos pontos fundamentais da Teoria Atômica proposta por John Dalton [15] era que
a matéria é constituída por unidades indivisíveis, os átomos. Estes, unidos uns aos outros,
compõem as moléculas, que juntas formam uma célula. Segundo a teoria celular [7][8],
formulada em 1839, por Schleiden e Schwann, todo ser vivo é formado por células. De
forma simplista, a vida resulta de um complexo conjunto de reações bioquímicas que ocorrem
nas células. Duas estruturas se destacam nesta química da vida: os ácidos nucléicos
e as proteínas.
A Biologia Molecular é a ciência onde se visa compreender a estrutura e função
dos ácidos nucléicos e proteínas, e como estes participam nos intrincados processos responsáveis
pela origem e conservação da vida citeSetubal.
2.1.1 Ácidos Nucléicos
A história da descoberta dos ácidos nucléicos remonta aos fins do século XIX, quando F.
Miescher (1868), em um importante trabalho de citoquímica, isolou e analisou o núcleo das
células. No entanto, foi Richard Altmann que, em 1889, atribuiu a designação de ácidos
nucléicos, uma vez que foram primeiramente identificados no núcleo e porque manifestam
propriedades ácidas.
Os ácidos nucléicos estão presentes em todos os seres vivos, sejam eles simples ou
complexos, e contêm as informações necessárias para a síntese de todas as proteínas que
cada organismo é capaz de produzir [59]. São moléculas orgânicas gigantes formadas por
uma cadeia de unidades menores chamadas nucleotídeos. Existem dois tipos principais: o
ácido ribonucléico (RNA) e o ácido desoxirribonucléico (DNA).
Cada nucleotídeo do ácido nucléico consiste de três partes básicas: um grupo fosfato,
um açúcar e uma base nitrogenada (anel heterocíclico de átomos de carbono e nitrogênio).
A base nitrogenada, de acordo com sua estrutura química, pode ser púrica ou pirimídica.
Adenina (A) e guanina (G) são bases púricas enquanto citosina (C), timina (T)
e uracila (U) são bases pirimídicas.
11

As purinas são constituídas de dois anéis fundidos de 5 e 6 átomos e as pirimidinas
de um único anel de 6 átomos. Uracil e Timina são moléculas bastante relacionadas,
diferindo apenas pelo grupo metila encontrado no átomo C5 do anel pirimídico da Timina
(figura 2.1). É a presença do nitrogênio que dá a essas moléculas o seu caráter básico.
Apenas quatro tipos diferentes de bases são encontrados em um dado polímero de
ácido nucléico, sendo duas purinas e duas pirimidinas. No DNA as bases constituintes são
A, G, C, e T, enquanto que no RNA as bases são A, G, C e U.
Figura 2.1: Bases Nitrogenadas.
A molécula de açúcar, também chamada de pentose por ser composta de 5 átomos
de carbono, pode ser de dois tipos, desoxirribose e ribose. Diferem uma da outra pela
presença ou ausência do grupo hidroxila no C2’ (figura 2.2). É baseado nessa característica
que os ácidos nucléicos recebem o nome RNA (ribose) ou DNA (desoxirribose).
Figura 2.2: Tipos de Açúcares.
A pentose é o elo de ligação entre a base e o grupo fosfato. De um lado, o Nitrogênio
9 das purinas ou o Nitrogênio 1 das pirimidinas liga-se ao C1’ da pentose e, de outro lado,
o grupo carboxila do átomo de C5’ da pentose participa da ligação éster com o grupo
fosfato.
12

2.1.1.1 DNA
Segundo o modelo descoberto por Watson-Crick [72], o DNA é uma longa molécula,
constituída por duas cadeias de nucleotídeos (um grupo fosfato, um açúcar e uma base
nitrogenada), chamadas fitas, enroladas em torno de seu próprio eixo, como se fosse uma
escada do tipo caracol (figura 2.3). A ligação entre as fitas é feita por pontes de hidrogênio,
que são ligações fracas, isto é, que se rompem com facilidade. As pontes de hidrogênio
unem duas bases nitrogenadas e são decorrentes de propriedades químicas entre uma base
púrica e uma pirimídica, formando os chamados pares de bases (bp).
Figura 2.3: A estrutura de uma molécula de DNA, formada por uma dupla fita. (a) Forma
helicoidal da dupla cadeia. (b) Forma esquemática da dupla cadeia, onde podemos visualizar a
ligação entre as moléculas de açúcar (S) e de fosfato (P), em cada uma das fitas, e o emparelhamento
das bases Adenina/Timina e Citosina/Guanina, entre as duas fitas.
O pareamento das bases de cada fita se dá de maneira padronizada, sempre uma
purina com uma pirimidina, especificamente: adenina (A) com timina (T) e citosina (C)
com guanina (G).
Como cada ligação ocorre entre o carbono 3’ de um composto, o fosfato e o carbono
5’ do próximo composto, diz-se que o DNA possui uma orientação que, por convenção,
inicia-se na extremidade 5’ e termina na 3’, denominada direção canônica [64]. Assim,
uma seqüência de nucleotídeos em uma fita corresponde à seqüência dos nucleotídeos
complementares da outra fita, por causa do emparelhamento das bases. Dizemos que as
duas fitas são complementares.
Além disso, deve-se notar que as duas fitas possuem sentidos opostos. Uma fita começa
em 5’ e termina em 3’, que é emparelhada com a outra, que começa em 3’ e termina em 5’.
13

Por convenção, a fita de sentido 5’ → 3’ é colocada acima, como mostrado na figura 2.4.
Figura 2.4: Dupla fita de DNA, observando-se o pareamento das bases A-T e C-G.
A seqüência do DNA é determinada pela ordem das bases nitrogenadas ao longo de
cada uma das fitas, já que o fosfato (P) e o açúcar (S) são idênticos em todos os nucleotídeos.
Daí os pares de bases (bp) serem usados como unidades de comprimento para
uma molécula de DNA. O tamanho do DNA varia para cada organismo, podendo ser de
alguns milhões de bases, como no caso de uma bactéria, até de alguns bilhões de bases,
no caso dos mamíferos.
O DNA codifica todas as proteínas que as células devem sintetizar, o que garante
a sobrevivência da espécie. Portanto, a principal função do DNA é armazenar toda a
informação genética de um organismo. A conservação e transmissão dessas informações
são realizadas pelos processos de duplicação e transcrição, respectivamente.
2.1.1.2 RNA
As moléculas de RNA possuem composição química e estrutural bastante similares às
de DNA. As diferenças químicas estão no fato de o nucleotídeo ser formado pelo açúcar
ribose e pela substituição da timina (T) pela uracila (U). As outras bases nitrogenadas
são todas as mesmas que compõem o DNA: citosina (C), guanina (G) e adenina (A).
Estruturalmente, enquanto o DNA apresenta-se como uma longa hélice dupla com uma
estrutura secundária regular e simples, os RNAs são, geralmente, moléculas de fita única
bem menores que o DNA, apresentando uma enorme diversidade de estruturas secundárias,
com certas regiões podendo formar até mesmo uma dupla hélice.
A estabilidade e regularidade estrutural da molécula de DNA, deve-se principalmente
ao fato dos anéis de desoxirribose não possuírem grupos hidroxila no C2’. Os grupos
hidroxila tanto do C2’ como C3’ são muito reativos e podem participar de uma série de
ligações pouco usuais, permitindo uma variedade enorme de conformações para a molécula
de ácido nucléico. Tal variedade, não seria uma característica desejável para uma molécula
que tem armazenado e transmitido a informação genética durante estes milhões de anos
de evolução. O exercício de tal função exige estabilidade e regularidade.
Já o RNA, constituído de riboses é, por isso mesmo, muito mais reativo e flexível.
Além disto, o fato de ser fita simples permite um emparelhamento intramolecular de
bases, gerando estruturas bastante complexas. Ao adquirir diferentes conformações numa
estrutura tridimensional, as moléculas de RNA podem, inclusive, apresentar sítios ativos
14

que catalisem reações químicas da mesma forma que as enzimas protéicas.
É a grande flexibilidade dos RNAs que lhes permite executar uma atividade fundamental
na célula, qual seja, a de interpretar o código contido na linguagem de nucleotídios
e decodificá-lo para a linguagem de aminoácidos. A molécula de RNA é o intermediário
no fluxo de informações dentro da célula, do DNA às proteínas. Assim, existem diferentes
tipos de RNA, tais como o RNA mensageiro (RNAm), o RNA ribossômico (RNAr) e
o RNA transportador (RNAt), responsáveis por diversas funções vitais na realização da
síntese de proteínas.
A tabela 2.1 apresenta as diferenças fundamentais entre o DNA e o RNA.
2.1.2 Aminoácidos
De um modo geral, cada composto orgânico pertence a um determinado grupo. Entretanto,
existem compostos que pertencem simultaneamente a dois ou mais grupos, ou
seja, são de função mista. A figura 2.5 mostra alguns desses grupos.
Figura 2.5: Exemplo de alguns grupos orgânicos.
Os aminoácidos são compostos orgânicos de função mista e que apresentam em suas
moléculas um grupo ácido (-COOH) e um grupo amina (-NH2), além de um radical -R, que
vai ser responsável pela diferenciação entre os diversos tipos existentes (figura 2.6). Graças
à presença de grupamentos derivados de ácidos carboxílicos e de aminas, os aminoácidos
são dotados de propriedades de ácidos e bases. Esse duplo caráter é de vital importância
para a compreensão do comportamento e das funções das proteínas e, por conseguinte, da
matéria viva.
Todas as proteínas existentes nos seres vivos, desde os vírus até os seres humanos, são
constituídas por combinações de apenas 20 aminoácidos. Esses blocos constituintes da
Tabela 2.1: Principais diferenças entre o DNA e o RNA.
DNA
RNA
Nucleotídeo fosfato, desoxirribose, fosfato, ribose,
base nitrogenada base nitrogenada
Bases Nitrogenadas A, T, C e G A, U, C e G
Estrutura duas cadeias normalmente,
em estrutura helicoidal cadeia simples
Função única varia de acordo com o tipo
15

Figura 2.6: Estrutura e exemplos de alguns aminoácidos.
vida se unem entre si para formar longas cadeias e moléculas complexas que configuram a
estrutura de todos os organismos vivos. A tabela 2.2 mostra os aminoácidos encontrados
na natureza, bem como suas abreviações e códigos utilizados.
Os aminoácidos são classificados em essenciais e não-essenciais. Os essenciais, ou
indispensáveis, são aqueles que o organismo humano não consegue sintetizar. Desse modo,
eles devem ser obrigatoriamente ingeridos através de alimentos. Os aminoácidos nãoessenciais,
ou dispensáveis, são aqueles que o organismo humano consegue sintetizar a
partir dos alimentos ingeridos.
São 8 os aminoácidos essenciais, a saber: leucina, isoleucina, valina, triptofano, metionina,
fenilalanina, treonina e lisina (a histidina é um aminoácido essencial na infância,
mas não na idade adulta).
2.1.3 Proteínas
As proteínas são compostos orgânicos de estrutura complexa e massa molecular elevada
(entre 15.000 e 20.000.000) e são sintetizadas pelos organismos vivos através da condensação
de um número grande de moléculas de aminoácidos, por intermédio de ligações
denominadas peptídicas, que derivam da reação do grupo amina de um dos aminoácidos
com o grupo carboxila de outro (figura 2.7). Pelo fato de uma molécula de água ser liberada
como resultado dessa reação, cada aminoácido, após a união, passa a ser um resíduo
do aminoácido original.
Figura 2.7: União de dois aminoácidos por uma ligação peptídica.
Para que as células funcionem são necessárias a realização de uma enorme quantidade
de reações químicas que se processam em seu interior. As enzimas, proteínas especiais,
regulam a atividade celular controlando e catalisando essas reações químicas.
Além disso, as proteínas participam nos processos de duplicação, transcrição e reparo.
A vida e a reprodução dependem da manutenção desses processos e da disponibilidade de
16

Tabela 2.2: Os 20 diferentes tipos de aminoácidos encontrados na natureza.
Aminoácido Abreviação Código
Alanina Ala A
Asparagina ou Aspartato Asx B
Cisteína Cis ou Cys B
Aspartato (Ácido aspártico) Asp D
Glutamato (Ácido glutâmico) Glu E
Fenilalanina Fen ou Phe F
Glicina Gli ou Gly G
Histidina His H
Isoleucina Ile I
Lisina Lis ou Lys K
Leucina Leu L
Metionina Met M
Asparagina Asn N
Prolina Pro P
Glutamina (Glutamida) Gln Q
Arginina Arg R
Serina Ser S
Treonina Ter ou Thr T
Valina Val V
Triptofano (Triptofana) Trp W
Tirosina Tir ou Tyr Y
Glutamina ou Glutamato Glx Z
17

energia e dos componentes necessários para isso. Dessa forma, a síntese das proteínas é
fundamental para o crescimento, o desenvolvimento e a manutenção celular.
Para a formação de uma proteína é preciso uma informação que irá ditar a seqüência
em que os aminoácidos devem ser unidos. Essas informações estão inscritas nas moléculas
do DNA.
Embora a seqüência de aminoácidos determine a estrutura da proteína, conhecida
como estrutura primária, não é possível predizer com precisão a conformação espacial
adotada por uma determinada proteína, apenas por esta seqüência. As interações moleculares
entre os aminoácidos fazem com que a cadeia protéica assuma uma estrutura
secundária. Podemos ter ainda as estruturas terciárias, resultado da estrutura secundária
empacotadas em um nível mais global, e as estruturas quaternárias, quando
um grupo de proteínas diferentes são empacotadas juntas.
É possível também classificar proteínas com base em sua função. Elas podem ser divididas
em dois grupos: proteínas estruturais e proteínas biologicamente ativas. Algumas
proteínas, entretanto, podem pertencer aos dois grupos. A maioria das proteínas estruturais
é composta por cadeias alongadas e têm como função compor estruturas de órgãos,
tecidos, etc. Dois bons exemplos, nos animais, são o colágeno (ossos, tendões, pele e
ligamentos) e a queratina (unhas, cabelos, penas e bicos). A maioria das proteínas biologicamente
ativas tem forma globular e são encarregadas de executar ou controlar a maior
parte das atividades dentro do organismo. Exemplos são as enzimas que aceleram reações
químicas, os hormônios protéicos (que atuam como mensageiros químicos), as proteínas de
transporte (como as lipoproteínas, que podem carregar o colesterol) e as imunoglobulinas
(ou anticorpos), que protegem o corpo de microorganismos invasores [64].
2.1.4 Genes
Nas células dos organismos, cada molécula de DNA forma um cromossomo. O
número de cromossomos é característico da espécie. Por exemplo, nas células dos seres
humanos existem 23 pares de cromossomos.
Cada molécula de DNA contém diversos genes, que são as unidades físicas e funcionais
básicas da hereditariedade [2]. Um gene é uma seqüência específica de bases de
uma molécula de DNA que contém a informação necessária para sintetizar proteínas ou
RNA [2].
Todos os genes estão dispostos linearmente ao longo dos cromossomos na forma de trechos
contíguos. Mas, entre os genes, existem trechos, chamados DNA não-codificante
que não possuem função codificadora, pelo conhecimento atual da ciência. Nos procariontes,
organismos que não possuem núcleo organizado, os cromossomos estão quase totalmente
cobertos por genes, mas, nos eucariontes, organismos com núcleo bem definido,
estima-se que cerca de 90% do cromossomo seja DNA não-codificante [64].
O conjunto completo de cromossomos de um organismo compreende o seu genoma,
18

que engloba todas as informações necessárias para originar e manter a vida. A figura 2.8
mostra o esquema dos genes dentro dos cromossomos e destes dentro do genoma. Estimase
que o genoma humano possua aproximadamente 30.000 genes [2].
Figura 2.8: Visão esquemática dos genes, cromossomos e genoma.
Geralmente, cada gene em uma molécula de DNA corresponde a um tipo diferente
de proteína. A informação genética contida nos genes é transmitida por triplas de nucleotídeos,
chamadas códons. Cada códon representa um aminoácido na proteína e essa
correspondência é chamada de código genético (figura 2.9).
Figura 2.9: Código genético.
A combinação das quatro letras genéticas (A,T,C,G) três a três permite obter 64 trincas
diferentes. Dessas 64 trincas possíveis, apenas 61 correspondem a aminoácidos; as três
restantes são utilizadas para indicar onde termina um mensagem genética (STOP). Em
geral, o início de um gene é indicado pelo códon AUG.
Como existem apenas 20 tipos diferentes de aminoácidos nas proteínas do seres vivos,
alguns aminoácidos são codificados por mais de uma trinca de nucleotídeos. Por isso,
diz-se que o código genético é degenerado.
2.1.5 Genética Molecular
O material responsável pelo comando e coordenação de toda a atividade celular e
pelas divisões celulares e transmissões das características hereditárias está representado
19

Figura 2.10: Duplicação do DNA.
nas células pelos cromossomos. A conservação e a transmissão da informação genética
ocorrem devido ao processo de duplicação do DNA, que acontece durante a divisão de
uma célula, produzindo duas células filhas exatamente iguais.
Na duplicação, as fitas do DNA se separam e cada uma serve de molde para a formação
de uma fita complementar através do pareamento de bases. No final do processo haverá
duas moléculas de DNA, cada uma constituída por uma fita original e outra complementar
recém-fabricada (figura 2.10). É geralmente durante este processo que ocorrem as variações
genéticas decorrentes de mutações, por exemplo, substituições, remoções ou inserções de
bases.
2.1.6 Síntese Protéica
A expressão da informação genética ocorre na forma de proteínas, segundo o Dogma
Central da Biologia Molecular, que preconiza que os genes são perpetuados como
seqüências de ácidos nucléicos e, a partir destes, expressos na forma de proteínas. Duas
fases compõem o processo de síntese de proteínas: transcrição e tradução.
Na primeira etapa da síntese, ocorre a transcrição da informação depositada no
DNA para uma cópia feita a partir de ribonucleotídeo. Assim, obtém-se uma molécula
alongada de RNA com a mesma seqüência de nucleotídeo observada no DNA, com exceção
da base timina substituída pela uracila. Esta cópia de DNA recebe o nome de RNA
mensageiro (RNAm). O RNAm carrega a informação codificada para os ribossomos,
que são estruturas celulares responsáveis por processar o código genético e sintetizar as
proteínas [2].
Terminada a transcrição do DNA, o RNAm sai do núcleo para o citoplasma rumo ao
ribossomo, levando a seqüência de nucleotídeos que permitirá a formação das proteínas.
Para que isso ocorra é necessário a tradução da seqüência de nucleotídeos do RNAm em
seqüência de aminoácidos (figura 2.11).
20

Figura 2.11: Representação esquemática da transcrição e tradução.
Todas as células contêm um conjunto de RNA, os RNA transportadores (RNAt), que
através da ligação de uma de suas extremidades a um códon, permite o alinhamento dos
aminoácidos de acordo com a seqüência de nucleotídeos do RNAm.
Um RNAt é responsável pelo transporte de um dos vinte aminoácidos utilizados na
síntese de proteínas. Cada um dos aminoácidos tem pelo menos um tipo de RNAt a
ele designado. O aminoácido é ligado ao RNAt que possui um anticódon (seqüência
de três nucleotídeos que é complementar aos três nucleotídeos do códon que especifica o
aminoácido na molécula de RNAm) correto, gerando uma molécula de aminoacil-RNAt.
Através do pareamento códon-anticódon, o aminoácido é inserido em uma cadeia crescente
de proteína, de acordo com o que está determinado na seqüência de nucleotídeo do RNAm.
Com uma extremidade ligada a um aminoácido e a outra pareada a um códon, o RNAt
converte a seqüência de nucleotídeo na seqüência de aminoácidos (figura 2.12). Apenas a
molécula de RNAt, e não os aminoácidos a ela ligados, determina onde o aminoácido é
adicionado durante a síntese de proteína.
Figura 2.12: Detalhamento do processo de tradução.
21

2.2 Algoritmos para Comparação de Seqüências Baseados
em Programação Dinâmica
A comparação de seqüências é a operação primitiva mais importante em Bioinformática,
servindo como base para muitas outras manipulações complexas e é vastamente utilizada
nos projetos de seqüenciamento.
A comparação de seqüências consiste em duas partes: encontrar uma medida que indique
a similaridade entre as seqüências, e obter uma forma de visualizar esta similaridade.
A similaridade é uma métrica que expressa quantitativamente quão parecidas são duas
seqüências. Já a visualização é feita por um alinhamento, que é um método de escrever
uma seqüência acima da outra para tornar explícitas as correspondências entre caracteres
ou regiões de caracteres similares das duas seqüências.
O melhor alinhamento, ou
alinhamento ótimo, é aquele que apresenta o máximo de regiões de similaridade [64].
2.2.1 Alinhamento de seqüências
Quando seqüências são comparadas, diversos termos podem ser utilizados para expressar
o resultado encontrado. Identidade, similaridade e homologia de seqüências são
os mais importantes, e embora sejam freqüentemente utilizados de forma intercambiável,
seus significados são diferentes.
A identidade entre seqüências se refere à ocorrência exata dos mesmos resíduos nas
mesmas posições das seqüências alinhadas. A similaridade considera a possibilidade de
ocorrência de mutações, sendo significativa quando estas são pontuadas de acordo com
a probabilidade que têm de ocorrerem, sob um ponto de vista biológico. A homologia
indica a existência de um relacionamento evolucionário entre as seqüências. A diferença
entre os dois últimos termos é que a similaridade se refere à presença de locais idênticos
ou similares nas seqüências, enquanto a homologia reflete uma afirmação mais forte, a de
que as seqüências possuem um ancestral comum.
Comparar seqüências depende da computação de um alinhamento entre elas. Para
isso, é utilizado um esquema de pontuação do alinhamento. Cada coluna do alinhamento
recebe um certo valor dependendo do seu conteúdo. A soma desses valores consiste na
pontuação do alinhamento.
Assim, as seqüências a serem comparadas são emparelhadas, ou seja, posicionadas uma
acima da outra, de modos arbitrários e para cada um desses emparelhamentos é calculado
um valor de acordo com certos critérios. O melhor alinhamento dentre todos os possíveis
será aquele que possuir a maior pontuação.
máximo, ambos serão considerados ótimos.
Se dois alinhamentos resultarem no valor
Um alinhamento de seqüências deve permitir introdução de espaços (gaps) em locais arbitrários
das seqüências para compensar inserções ou remoções de bases de uma seqüência
em relação a outra. A inclusão de espaços mantém, em registro, seqüências obviamente
22

similares, o que não seria possível com um alinhamento direto sem eles. Assim, os espaços
nos permitem lidar com contingências tais como duplicações internas, repetições, crossingover
desigual e outras delinqüências genéticas. Não é permitido que um espaço em uma
seqüência seja alinhado com um espaço na outra seqüência.
Cada coluna do alinhamento recebe um certo valor dependendo do seu conteúdo. A
soma desses valores resulta na pontuação do alinhamento. Um esquema de pontuação
muito utilizado define um valor igual a +1 para colunas com caracteres coincidentes (matches)
e −1 para colunas com caracteres divergentes (mismatches). Para impedir o acúmulo
de muitos espaços em um alinhamento, uma quantidade fixa deve ser deduzida do valor
acumulado a cada espaço introduzido. Assim, os espaços possuem pontuação negativa.
Esse esquema de pontuação sugere o valor −2 para cada espaço inserido. Pode ainda ser
definida uma penalidade mais suave para a extensão do espaço (espaços sucessivos).
Por exemplo, considerando duas seqüências x = CCT AGA e y = CT AT GCAC, um
possível alinhamento entre elas é mostrado na figura 2.13 e resultaria em uma pontuação
(escore) igual a −5.
Figura 2.13: Pontuação de um possível alinhamento entre CCTAGA e CTATGCAC.
Nas comparações de seqüências de DNA, utiliza-se uma matriz unitária onde somente
caracteres idênticos recebem uma pontuação positiva. No caso de se comparar
seqüências protéicas, utilizam-se matrizes de substituição. Aminoácidos relativamente
semelhantes recebem pontuação positiva e não semelhantes recebem pontuação negativa.
Uma matriz de comparação para proteínas, amplamente utilizada nos últimos anos, foi a
matriz PAM ( Point Accepted Mutation), construída por Dayhoff [16].
Para construí-la, ele observou todas as substituições de aminoácidos verificadas em
alinhamentos de um amplo conjunto de proteínas intimamente relacionadas, as quais
tinham sofrido uma certa divergência evolucionária. A cada substituição possível de um
resíduo foi dada uma pontuação que reflete a probabilidade de estar relacionado ao resíduo
correspondente da seqüência em consulta. A pontuação do alinhamento é a soma das
pontuações individuais e mede a quantidade de alterações evolutivas numa seqüência. Em
média, 1,0 unidade PAM corresponde a alterações em 1% dos aminoácidos numa seqüência
protéica.
Um método alternativo, baseado nas matrizes BLOSUM (Blocks Substitution Matrix)
[27] tem se mostrado superior à matriz PAM para detectar os parentescos biológicos
entre seqüências moderadamente divergentes. No caso da matriz BLOSUM62, por exem-
23

plo, o máximo de identidade compartilhado por duas seqüências é 62% e os scores são
derivados da comparação de blocos de alinhamentos localizados nas proteínas relacionadas.
Dependendo do tamanho das seqüências que estão sendo comparadas, matrizes de
um tipo ou de outro são mais apropriadas.
2.2.2 Algoritmos baseados em programação dinâmica
Waterman mostrou que encontrar alinhamentos é um problema difícil, já que o número
de alinhamentos possíveis é exponencial, dado aproximadamente pela fórmula [71]
onde n representa o tamanho das seqüências.
A n = (1 + √ 2) 2n+1√ n, (2.1)
2.2.2.1 Comparação global
Em 1970, Needleman e Wunsch [51] apresentaram o primeiro algoritmo de comparação
de seqüências capaz de determinar o melhor alinhamento entre duas seqüências sem enumerar
todas as soluções possíveis. A solução foi baseada em técnicas de programação
dinâmica [13], que se baseia no princípio de que uma instância de um problema é resolvida
aproveitando as soluções já computadas para instâncias menores deste problema.
Programação dinâmica é aplicada tipicamente em problemas de otimização, para os
quais deve-se construir um conjunto de escolhas visando obter uma solução ótima. À
medida que estas escolhas são feitas, formam-se sub-problemas similares ao problema original.
A idéia básica desta técnica é calcular o valor de cada sub-problema uma única vez,
armazenando-o em uma tabela, e usar este valor sempre que o sub-problema correspondente
reaparecer durante a execução do algoritmo que soluciona o problema.
Existem duas características básicas que um problema de otimização deve ter para
que a programação dinâmica possa ser aplicada: sub-estrutura ótima e sub-problemas
que se sobrepõem. Dizemos que um problema exibe sub-estrutura ótima quando uma
solução ótima para o problema é calculada a partir de soluções ótimas para sub-problemas
similares, mas menores que o problema original. Em relação à segunda característica,
para que um problema possua sub-problemas que se sobrepõem, o espaço de subproblemas
deve ser pequeno, no sentido de que um algoritmo recursivo para o problema
resolve os mesmos sub-problemas várias vezes, em vez de gerar diferentes sub-problemas.
Tipicamente, o número total de sub-problemas distintos deve ser polinomial em relação
ao tamanho da entrada.
Dadas duas seqüências x e y, em vez de determinar a similaridade entre x e y tomando
as duas seqüências inteiras, a solução pode ser obtida determinando todas as similaridades
entre prefixos arbitrários das duas seqüências, iniciando pelos prefixos menores e utilizando
os resultados já processados para resolver o problema para prefixos maiores.
24

Este algoritmo reduziu a complexidade de tempo do problema de exponencial para
quadrática, implementando um método de alinhamento global, que busca a similaridade
máxima, pois prioriza os pareamentos (coincidências e divergências) e penaliza
inserções e remoções (espaços) de bases, considerando o tamanho total das seqüências
sendo comparadas. Este tipo de alinhamento é apropriado quando se espera encontrar
similaridades ao longo de toda ou na maior parte das seqüências.
Seguindo a técnica de programação dinâmica, a idéia básica do algoritmo consiste em
dividir o problema de encontrar o melhor alinhamento entre duas seqüências em subproblemas
de alinhar pares de bases, uma de cada seqüência, para encontrar subalinhamentos
ótimos.
alinhamentos possíveis:
A solução de cada subproblema é dada pela escolha de um dos três
• Alinhar as bases das duas seqüências;
• Alinhar um espaço na primeira seqüência com a base da segunda seqüência;
• Alinhar a base da primeira seqüência com um espaço na segunda seqüência.
Para comparar duas seqüências x = x 1 x 2 . . . x |x| e y = y 1 y 2 . . . y |x| , onde |x| representa
o comprimento da seqüência x e |y| o comprimento da seqüência y, o algoritmo gera uma
matriz S |x|+1,|y|+1 , chamada de matriz de similaridade. Para cada célula s i,j da matriz,
o algoritmo calcula a pontuação resultante de cada um dos três alinhamentos possíveis,
selecionando o de maior valor, conforme a equação de recorrência do algoritmo de
comparação global (equação 2.2).
⎧
⎪⎨ s i−1,j + ins
s i,j = max s i−1,j−1 + sub
⎪⎩
s i,j−1 + del
s i,0 = i × ins,
s 0,j = j × del,
i = 0, 1, . . . , |x|
j = 1, 2, . . . , |y|
(2.2)
Os valores ins, sub e del são pontuações referentes a inserções, substituições e remoções,
respectivamente. Conforme já citado, um esquema de pontuação muito utilizado [64]
sugere ins = del = −2 que é a penalidade para inserir um espaço em uma das duas
seqüências (alinhamento de uma base com um espaço). Para a substituição, temos sub =
+1 se as duas bases x i e y j comparadas forem iguais ou sub = −1, caso contrário.
A figura 2.14 mostra a matriz de similaridade obtida com a aplicação da equação de
recorrência (equação 2.2) nas seqüências x = AACGT e y = AGT .
A seqüência x é
posicionada ao longo das colunas e y ao longo das linhas da matriz. A primeira linha e a
primeira coluna, conforme a equação 2.2, são inicializadas com múltiplos da penalidade do
espaço (−2 com o esquema de pontuação utilizado). Isto se deve à existência de apenas um
alinhamento possível se uma das seqüências está vazia: apenas adicionar tantos espaços
quanto forem os caracteres da outra seqüência. O escore deste alinhamento é −2k, onde k
é o tamanho da seqüência não vazia. Para calcular as demais entradas (i, j) da matriz, só é
preciso obter os valores computados para as três entradas anteriores: (i−1, j), (i−1, j −1)
25

e (i, j−1), em função de haverem apenas três formas de obter um alinhamento entre x [1..i]
e y [1..j]. De fato, para obter um alinhamento entre x [1..i] e y [1..j], temos as seguintes
escolhas:
• Alinhar x [1..i] com y [1..j − 1] e combinar um espaço com y [j], ou
• Alinhar x [1..i − 1] com y [1..j − 1] e combinar x [i] com y [j], ou
• Alinhar x [1..i − 1] com y [1..j] e combinar x [i] com um espaço.
Figura 2.14: Matriz de similaridades das seqüências x = AACGT e y = AGC.
Os ponteiros nessa matriz indicam qual dos três valores da equação de recorrência foi
a origem da maior pontuação para a célula em questão. O preenchimento da matriz de
similaridade pode ser feito tanto linha a linha, da esquerda para a direita em cada linha,
ou coluna a coluna, de cima para baixo, em cada coluna. Qualquer outra ordem que torne
disponível s [i, j − 1], s [i − 1, j − 1], s [i − 1, j] quando o valor de s [i, j] for computado,
também pode ser utilizada.
Com a matriz preenchida, o segundo passo é identificar o melhor alinhamento global.
Para isso, é utilizado um procedimento de rastreamento no sentido inverso pela
matriz, chamado backtracking, iniciando pelo elemento s [|x| + 1, |y| + 1], seguindo o direcionamento
indicado pelos ponteiros de cada célula visitada até chegar na entrada s [0, 0]
(figura 2.15). Cada ponteiro usado fornecerá uma coluna do alinhamento. Para uma dada
célula (i, j) da matriz, se o ponteiro for uma seta horizontal, ela corresponde a um espaço
inserido em x combinando com y [j]; se for uma seta vertical, então corresponde a x [i]
combinado com um espaço inserido em y; finalmente, se for uma seta diagonal corresponde
a x [i] combinando com y [j]. Como a primeira seqüência, x, é sempre colocada ao
longo das colunas, um alinhamento ótimo pode ser facilmente construído da direita para
a esquerda se tivermos a matriz S já calculada.
Note que existem valores que são origem de mais de um vetor. Se um desses valores
fizer parte do percorrimento reverso, todas as possibilidades deverão ser exploradas, pois
cada uma delas representa um alinhamento ótimo.
26

Figura 2.15: Obtenção do melhor alinhamento global.
Para o exemplo anterior, o seguintes alinhamento ótimos são obtidos pelo percorrimento
reverso, com x sendo a linha superior e y a inferior:
A A C G T
A − − G T
e
A A C G T
− A − G T
Para determinar a complexidade do algoritmo descrito, notamos que o número de
operações executadas depende, essencialmente, do número de células da matriz que devem
ser computados, isto é, do seu tamanho. Assim, supondo duas seqüências com comprimentos
m e n, será gasto um tempo O(mn) nesses cálculos e este é o termo dominante
da complexidade de tempo. O espaço utilizado também é proporcional ao tamanho da
matriz. Se as seqüências tiverem o mesmo ou aproximadamente o mesmo tamanho, n,
teremos complexidade de espaço e tempo de O(n 2 ), ou seja, uma complexidade quadrática.
2.2.2.2 Comparação local
O algoritmo de Needleman-Wunsch atribui uma penalidade constante, w k = kw 1 ,
onde w 1 é a penalidade de inserção de um espaço, para seqüências de espaços, em uma
das seqüências alinhadas. No entanto, sob o ponto de vista biológico, quando ocorrem
eventos mutacionais em uma seqüência, a ocorrência de k espaços juntos é mais provável
do que a ocorrência de k espaços isolados. Em 1981, Smith e Waterman generalizaram
o algoritmo proposto por Needleman e Wunsch incorporando este critério, que atribui
penalidades para espaços juntos considerando os seus tamanhos (w k ≤ kw 1 ), e propuseram
um método de alinhamento local que, diferentemente do método de alinhamento global,
identifica sub-regiões de maior similaridade entre as seqüências comparadas [66].
Um alinhamento local de duas seqüências é definido como um alinhamento entre uma
subseqüência da primeira seqüência com uma subseqüência da segunda. A similaridade
das duas seqüências é definida como o escore máximo sobre todos os possíveis alinhamentos
locais.
Em várias aplicações biológicas, a identificação de regiões locais de similaridade em
27

seqüências longas é mais significativa do que a similaridade entre as seqüências inteiras,
pois o baixo valor desta pode esconder importantes fatos biológicos, só observáveis quando
se consideram as sub-regiões.
O algoritmo de Smith-Waterman é baseado em duas modificações no algoritmo de
Needleman e Wunsch:
• Quando o escore de um subalinhamento entre duas subsequências resulta em um
valor negativo, é atribuído escore zero, que indica que o subalinhamento não deve
ser prolongado;
• Não basta considerar três células da matriz, pois em função da penalidade não constante
para espaços juntos, é preciso verificar todas as células na mesma linha e todas
as células na mesma coluna. Conseqüentemente, a interpretação dos valores da matriz
é diferente. Cada entrada (i, j) irá armazenar o maior valor de um alinhamento
entre um sufixo de x [1..i] e um sufixo de x [1..j].
Neste caso, para encontrar o melhor alinhamento local, basta localizar a entrada da
matriz que possui o maior valor de escore e aplicar o procedimento de rastreamento no
sentido inverso até encontrar uma entrada com escore zero.
No entanto, em função do tratamento diferenciado para a atribuição de penalidades
para espaços juntos, o algoritmo de Smith-Waterman apresenta uma complexidade de
tempo de O(n 3 ).
Gotoh [23], em 1982, propôs uma forma de reduzir essa complexidade de tempo, modificando
o algoritmo de Smith-Waterman por meio de uma limitação na métrica utilizada
para espaços juntos. Sem afetar o critério de computar espaços juntos de tamanhos variados,
ele conseguiu reduzir a complexidade de tempo para O(n 2 ), utilizando uma forma
especial de penalidade para estes espaços juntos, chamada função de espaços juntos
afim, expressa pela fórmula w k = u +vk (u, v ≤ 0), onde u expressa a penalidade para inserir
o primeiro espaço, v indica o custo para estendê-lo e k indica o tamanho do conjunto
de espaços juntos. A equação 2.3 representa a proposta de Gotoh.
⎧
⎪⎨ p i,j
s i,j = max s i−1,j−1 + sub
⎪⎩
q i,j
{
si−1,j + w
p i,j = max
1
p i−1,j + v
{
si,j−1 + w
q i,j = max
1
q i,j−1 + v
s i,0 = p i,0 = q i,0 = 0,
s 0,j = p 0,j = q 0,j = 0,
i = 0, 1, . . . , |x|
j = 1, 2, . . . , |y|
(2.3)
Se a penalidade do espaço for constante como no algoritmo de Needleman-Wunsch,
a equação de recorrência do algoritmo de comparação local pode ser reduzida para a
equação 2.4.
28

⎧
⎪⎨
s i,j = max
⎪⎩
s i−1,j + w 1
s i−1,j−1 + sub
s i,j−1 + w 1
0
s i,0 = 0,
s 0,j = 0,
i = 0, 1, . . . , |x|
j = 1, 2, . . . , |y|
(2.4)
Embora não seja a equação mais correta do ponto de vista biológico, essa equação foi
a escolhida para a implementação feita nessa dissertação. A idéia é atacar o problema
com uma abordagem mais simples, e uma vez conhecidas suas peculiaridades, estender a
solução obtida para situações mais complexas.
Espaço Linear
A complexidade quadrática em espaço do algoritmo de Smith-Waterman, que reflete
a quantidade de memória necessária, pode torná-lo inviável quando seqüências muito
longas forem comparadas, já que manter a matriz de similaridades totalmente carregada
em memória possui um custo muito alto. No entanto, para o cálculo da posição s i,j , são
necessários apenas os valores s i−1,j , s i−1,j−1 e s i,j−1 . Logo, é preciso manter em memória
apenas a linha atual que está sendo calculada e a linha anterior, para consulta. Com isto,
a complexidade de espaço que era O(n 2 ) passa a ser O(2n). A complexidade de tempo
permanece O(n 2 ).
29

Capítulo 3
HARDWARE
3.1 Sistemas Dedicados
Arquiteturas tradicionais de computadores podem resolver uma diversidade muito
grande de problemas de computação, desde que lhes sejam submetidos diferentes programas,
cada qual com um propósito específico. Para a maioria das tarefas de computação,
esta abordagem, centrada na utilização de processadores de propósito geral (GPP), é mais
barata e rápida.
O principal foco do projeto de GPPs reside, pois, no desempenho e na funcionalidade
geral a ser proporcionada. Contudo, os custos de fabricação e projeto de arquiteturas
baseadas em processadores de propósito geral estão aumentando com rapidez [5]. Tais
custos compreendem três perceptíveis aspectos:
• Custos de hardware: os processadores de propósito geral são maiores e mais complexos
do que o necessário para resolver uma tarefa específica;
• Custos de projeto: unidades funcionais, raramente usadas em determinadas aplicações,
podem estar presentes em GPPs, tendendo a consumir uma parte considerável do
esforço de projeto;
• Custos de energia: muita energia é desperdiçada por unidades funcionais ou blocos
que não são usados durante grande porção do tempo de processamento.
Considerando-se aplicações específicas ou a exigência de requisitos em termos de consumo,
velocidade, tamanho e custos, podem ser adotados tipos especiais de processadores,
voltados para a aplicação em questão ou otimizados com vistas ao conjunto de requisitos
especificados. Sob esta ótica, somente as unidades funcionais necessárias, altamente otimizadas
para um conjunto de problemas do mesmo tipo, estão presentes, o que redunda
em economia de área e energia para o algoritmo específico às aplicações.
Dessa forma, sistemas computacionais dedicados são usados tipicamente em aplicações
específicas onde os sistemas de propósito geral não conseguem obter o desempenho esperado.
30

No desenvolvimento desses circuitos dedicados, o desempenho depende, na maioria das
vezes, mais da arquitetura do circuito do que da tecnologia de fabricação [12]. Este conceito
é largamente utilizado no projeto de sistemas de tratamento de sinais, por exemplo,
onde um processador com baixo custo executa uma filtragem mais rapidamente que um
poderoso Pentium®.
Para decidir sobre a utilização de um sistema dedicado e a arquitetura mais adequada,
diversos aspectos devem ser levados em conta.
Unidades simples e regulares
Como os sistemas dedicados possuem aplicação limitada, seu custo deve ser menor
que o benefício da utilização de uma arquitetura de propósito específico. Além do mais,
como os sistemas dedicados não são produzidos em larga escala, os custos de projeto
são mais importantes que os custos da fabricação das peças. Dessa forma, os custos de
projeto devem ser baixos de modo a tornar esses sistemas mais atrativos que os sistemas
de propósito geral.
Felizmente, a utilização de arquiteturas apropriadas pode reduzir significativamente
os custos de sistemas de propósito específico. Se uma determinada estrutura puder ser
decomposta em poucas unidades menores e mais simples, e essas serem utilizadas repetidamente,
uma grande economia pode ser obtida. Isto é especialmente verdade em projetos
de circuito integrados VLSI, onde um simples chip contém milhares de componentes. Em
adição, sistemas baseados em unidades simples e regulares são modulares e podem se
ajustar a diversos critérios de performance.
Operações de entrada e saída
Tipicamente, um sistema dedicado deve se comunicar com o mundo externo, recebendo
dados e entregando resultados. Não adianta o sistema fornecer resultados em uma velocidade
maior que o mundo externo é capaz de recebê-los. Assim, as operações de entrada e
saída (E/S) afetam bastante o desempenho geral de sistemas com arquiteturas específicas.
Outra dificuldade é quando cálculos extensos devem se feitos em sistemas de pequeno
porte. Neste caso, a computação deve ser decomposta em partes menores e os dados temporários
gerados armazenados para futuras referências. Isso aumenta muito a comunicação
com o ambiente externo.
Assim, várias considerações devem ser feitas sobre como minimizar o acesso externo,
como os requisitos de E/S afetam o sistema e sua memória interna e como a largura de
banda das operações de entrada e saída pode limitar o ganho de velocidade (speed-up).
31

Concorrência
O hardware é inerentemente paralelo. Ao se ligar um circuito eletrônico, todos os seus
transistores estão aptos a realizar alguma função. A utilização conveniente do paralelismo
encontra, basicamente, duas dificuldades: raciocínio serial e dependência de dados. O
primeiro problema é inerente à nossa forma de raciocinar, o segundo, advém das aplicações,
pois alguns resultados só podem ser processados após o término de outros.
Em termos de paralelismo, deve-se distinguir o modelo de hardware que se está tratando,
ou pelo menos, seu nível de abstração. Existe o paralelismo explícito de processos,
formado por um conjunto de máquinas, como em uma rede de computadores, ou por um
conjunto de processadores atuando em conjunto.
Um outro nível de paralelismo é aquele de processos de hardware completamente distintos,
executando funções complementares. Como exemplo, podemos ter um microprocessador
operando em paralelo com um temporizador e uma interface serial.
Finalmente, tem-se o paralelismo em nível de operações de hardware. Por exemplo,
no cálculo da equação y = x 2 + 3x + 1, a exponenciação pode ser feita em paralelo com a
multiplicação, pois não há dependência de dados para essas operações. Em geral, quanto
mais paralelismo estiver presente, mais rapidamente um algoritmo pode ser computado.
Contudo, maior será o preço do hardware final, seja na utilização de uma maior área de
silício em um CI, seja na quantidade de células lógicas necessárias em um FPGA.
Para limitar esse problema no paralelismo de operações, a questão a ser respondida é
qual o número mínimo de passos de relógio e qual o mínimo de componentes necessários
para executar o algoritmo na maior velocidade possível. As duas características combinadas
tendem a ser conflitantes. Para maior velocidade, precisa-se de um mínimo de passos,
mas para executar o algoritmo em um mínimo de passos, maior quantidade de hardware
deve estar disponível.
Existem algoritmos que permitem descobrir o menor número de passos necessários,
dada uma restrição de recursos. Entre esses, podemos citar o ASAP (as soon as possible),
ALAP (as late as possible) e ordenação de lista (list scheduling) [20][48][49]. Nesses
algoritmos, as operações são distribuídas em diversos passos de relógio, com o ASAP priorizando
as operações para o primeiro ciclo possível, o ALAP colocando as operações o
mais próximo do último ciclo de controle possível e a ordenação por listas utilizando as
tabelas do ASAP e ALAP para efetuar suas decisões.
Controle e comunicação
Quando um elevado número de processadores opera em paralelo, os custos de controle
(sincronização) e comunicação começam a ser tornar significativos. Se a granularidade for
fina, para facilitar o balanceamento de carga, podem ocorrer sobrecargas de comunicação
32

e sincronização.
Na análise do sistema, devemos verificar se o algoritmo a ser abordado com a arquitetura
dedicada suporta um alto grau de paralelismo e ao mesmo tempo pode ser
implementado com um controle e comunicação simples e regular.
No paralelismo de operações, também pode-se ter um alto custo de comunicação e
controle. Imagine que uma constante deva ser somada a 100 números, disponíveis em 100
registradores diferentes. Um conjunto de 100 somadores permitiria a soma em apenas
um ciclo de relógio. Se cada registrador pudesse ser carregado no mesmo ciclo, a cada
ciclo ter-se-iam 100 somas. Contudo, o custo de tal arquitetura é muito alto, pois além
dos 100 somadores e registradores, seriam necessários 100*n bits de entrada, onde n é
o número de bits de cada registrador, e, provavelmente, muito mais bits de saída pois
o resultado de cada soma será maior que os valores somados. Para piorar, se os dados
para os registradores vierem de uma memória externa e também devam ser armazenados
externamente, o problema adquire novas dimensões.
A conclusão é que, embora o paralelismo efetivamente acelere computações, seu custo
deve ser medido não somente em termos de operadores a mais, mas também no custo do
controle e comunicação para manterem o circuito paralelo ativo e funcional.
3.2 Arquiteturas Sistólicas
Uma possível solução para o projeto de sistemas dedicados são as arquiteturas sistólicas.
Esse conceito foi desenvolvido na universidade Carnegie-Mellon e originalmente proposto
para a implementação em VLSI de algumas operações sobre matrizes.
A origem desse nome vem da sístole, movimento de contração no qual o coração bombeia
o sangue para as artérias, da mesma forma que a memória “bombeia” dados para
dentro da estrutura sistólica e que depois retornam processados para essa memória (figura
3.1).
Figura 3.1: Aspecto geral de uma arquitetura sistólica.
Um sistema sistólico consiste em um conjunto de células (chamadas de elementos
de processamento) interconectadas, cada uma capaz de realizar alguma operação simples
[37]. Além disso, o controle e a comunicação entre as células é simples e regular.
Tipicamente, as células de uma estrutura sistólica estão organizadas na forma de matrizes
33

(unidimensionais ou bidimensionais) ou em árvores (figura 3.2). A comunicação com o
mundo externo ocorre apenas nas células das “bordas” do sistema.
Figura 3.2: Alguns tipos de estruturas sistólicas.
O princípio básico de um sistema sistólico é substituir um elemento de processamento
complexo por uma matriz de elementos de processamento simples e, conseqüentemente,
rápidos, todos capazes de manipular eficientemente um particular dado de entrada (que
percorre a estrutura), atingindo altas taxas de processamento com modesta utilização de
memória.
Para se avaliar a possibilidade de utilização dessa arquitetura em um particular problema,
as seguintes características do algoritmo ou sistema devem ser analisadas:
1. múltiplos usos de um único dado de entrada: devido a essa propriedade, pode-se
obter alta performance com poucas operações de entrada e saída;
2. uso intensivo de concorrência: o poder elevado de processamento de uma arquitetura
sistólica vem do uso de muitas células simples e rápidas atuando em paralelo no lugar
de um poderoso e único processador (ou poucos processadores);
3. pode-se decompor a solução em poucas estruturas simples: como uma grande quantidade
de elementos de processamento é utilizada, não deve haver muita variedade
desses elementos e eles devem ser o mais simples possível;
4. controle do fluxo de dados simples e regular: em um sistema sistólico, o único sinal
global deve ser o relógio do sistema. Os outros sinais de controle e comunicação
devem ficar restritos às células adjacentes da estrutura.
Resumindo, um sistema sistólico baseado nesses critérios será simples, modular e expansível,
com alta performance e possuindo poucos acessos à memória externa.
Devido a essas propriedades, as arquiteturas sitólicas são adequadas para tarefas computacionalmente
intensas, mas com poucas operações de entrada e saída.
34

Dentre as possíveis aplicações para esse tipo de arquitetura, destacam-se: DFT (Discrete
Fourier Transform) e FFT (Fast Fourier Transform), convolução, interpolação, multiplicação
de matrizes, triangularização de matrizes (solução de sistemas lineares), ordenamentos,
reconhecimento de voz, programação dinâmica, etc.
3.3 Sistemas Reconfiguráveis
A evolução contínua dos algoritmos e a diversidade das aplicações têm levado à concepção
de ambientes de hardware baseados em arquiteturas reconfiguráveis que possibilitem
a implementação de diferentes algoritmos em um mesmo suporte físico.
Muitas aplicações emergentes em telecomunicações e multimídia necessitam que suas
funcionalidades permaneçam flexíveis mesmo depois do sistema ter sido manufaturado [26].
Tal flexibilidade é fundamental, uma vez que requisitos dos usuários, características dos
sistemas, padrões e protocolos podem mudar durante a vida do produto. Essa maleabilidade
também pode prover novas abordagens de implementação voltadas para ganhos de
desempenho, redução dos custos do sistema ou redução do consumo geral de energia.
A flexibilidade funcional é comumente obtida através de atualizações de software, mas
desta forma a mudança é limitada somente à parte programável dos sistemas. Desenvolvimentos
recentes na tecnologia de matrizes de elementos lógicos programáveis no campo
(Field-Programmable Gate Arrays, ou FPGAs) têm introduzido suporte para modificações
rápidas e em tempo de execução do hardware do sistema.
Essas modificações referem-se a mudanças em circuitos digitais via reconfiguração.
A implementação de sistemas que exigem flexibilidade, alto desempenho, alta taxa de
transferência de dados e eficiência no consumo de energia são possibilitadas por essas
tecnologias. Isto inclui aplicações de televisão digital, sistemas de computação de alto desempenho,
processamento de imagens em tempo real, produtos para consumo atualizáveis
remotamente, entre outros.
Além das características citadas acima, a reconfigurabilidade também contribui para
a economia de recursos: quando uma dada tarefa pode ser realizada em várias fases, uma
diferente configuração pode ser carregada para cada fase seqüencialmente [70]. Desta
forma o tamanho do sistema pode ser menor, o que implica na redução de preço.
Para finalizar, a reconfigurabilidade também faz do desenvolvimento e teste de hardware
tarefas mais rápidas e mais baratas. Com o advento das FPGAs, a engenharia de
hardware foi capacitada a implementar projetos em nível de chip sem ter que fabricá-lo.
Segundo Page [54], há cinco estratégias de projeto pelas quais programas podem ser
embutidos em arquiteturas reconfiguráveis, sendo cada modelo mais apropriado a um
específico escopo de aplicações, apresentando diferentes compromissos entre custo e desempenho
(figura 3.3):
• Modelo de hardware puro: um dado algoritmo é convertido em uma única descri-
35

ção de hardware a qual é carregada em um FPGA. A configuração dá-se em tempo
de projeto e este modelo pode ser implementado a partir de linguagens de descrição
de hardware convencionais e das ferramentas de síntese atualmente disponíveis. É
interessante para o projeto e rápida prototipação de circuitos dedicados;
• Modelo de processadores voltados para uma aplicação: neste caso, um algoritmo
é compilado e obtêm-se dois resultados: um código de máquina abstrata e um
processador abstrato. A seguir, as partes são otimizadas para produzir a descrição
de um processador de aplicação específica e o código de máquina para ele;
• Modelo de reutilização seqüencial: a principal utilidade desta estratégia é notada
em situações nas quais determinado algoritmo é por demais extenso para ser
implementado nos dispositivos disponíveis, ou ainda, quando o projeto apresenta
restrições de área por razões econômicas ou de engenharia. Deste modo, o projeto
é subdividido em várias partes, as quais são submetidas a diferentes dispositivos,
redundando em um conjunto de passos de reconfiguração. Os ganhos relacionados
com a reutilização do hardware devem ser balanceados com o tempo que é gasto
com a reconfiguração;
• Modelo de múltiplo uso simultâneo: se porventura houver uma ampla disponibilidade
de dispositivos programáveis, vários algoritmos podem estar residentes e
serem executados simultaneamente, interagindo em diferentes graus de acoplamento
com o processador hospedeiro. É um modelo menos comum, requerendo mais área
do que a estratégia de reutilização seqüencial, mas é um método interessante para
a exploração da computação reconfigurável.
• Modelo de uso sob demanda: é muito interessante para a computação reconfigurável.
Pode ser adotado em uma ampla variedade de aplicações quando existe a
possibilidade de sistemas computacionais serem construídos onde o hardware não
existe todo ao mesmo tempo, mas cuja demanda de tempo-real do sistema dita qual
parte do hardware deve ser construída e qual parte deve ser destruída. Há uma
analogia razoável com sistemas de memória virtual, e por isto esse esquema pode
ser chamado de “hardware virtual”. Sua utilização cabe perfeitamente em sistemas
de tempo real e em sistemas que apresentam uma grande quantidade de funções e
operações não-concorrentes.
Sob a ótica da capacidade de reconfiguração proporcionada pelo projeto da arquitetura
reconfigurável, Adário [5] apresenta uma generalização dos modelos de execução definidos
por Page. Esta abordagem divide os modelos de projeto em três classes de capacidade
de programação, considerando o número de configurações e o instante em que ocorre
cada reconfiguração:
36

Figura 3.3: Modelos segundo a classificação de Page.
• Projeto Estático: o circuito possui uma única configuração que nunca é modificada.
O dispositivo programável é totalmente programado para executar uma única
função que permanece inalterada durante toda vida útil do sistema. Esta classe não
explora a flexibilidade provida pela reconfiguração; a única vantagem aproveitada
diz respeito às facilidades de projeto e prototipação conferidas pela reconfiguração;
• Projeto Estaticamente Reconfigurável: o circuito apresenta várias configurações,
e as reconfigurações acontecem apenas ao final de cada tarefa de processamento. Dependendo
da granularidade das tarefas executadas entre sucessivas reconfigurações,
pode-se dizer que este modelo efetua reconfiguração em tempo de execução. Neste
modelo, os dispositivos programáveis são usados de forma mais proveitosa. Arquiteturas
desta classe são chamadas de SRA – Statically Reconfigurable Architecture;
• Projeto Dinamicamente Reconfigurável: o circuito também apresenta várias
configurações e as reconfigurações acontecem, de fato, em tempo de execução. Este
tipo de projeto utiliza eficientemente as arquiteturas reconfiguráveis. O overhead
acarretado pela reconfiguração em tempo de execução precisa ser bem caracterizado
no domínio do conjunto das possíveis configurações. As arquiteturas resultantes
desta classe são denominadas DRA – Dynamically Reconfigurable Architecture.
As vantagens que podem ser auferidas da reconfiguração em tempo de execução dependem
muito do algoritmo em questão e da granularidade das tarefas que o compõem.
Por sua vez, o overhead de reconfiguração está fortemente vinculado à microarquitetura
das FPGAs utilizadas.
37

Geralmente, as aplicações, cuja implementação em arquiteturas reconfiguráveis é desejável,
apresentam três características básicas, a saber[4]:
• Regularidade: implica na execução das mesmas operações básicas repetidamente;
• Alta concorrência: refere-se à existência de um grande número de operações que
são efetuadas concomitantemente;
• Dados com granularidade fina: diz respeito ao pequeno tamanho dos operandos.
Dadas tais características, podem ser arroladas aplicações passíveis de implementação
profícua em arquiteturas reconfiguráveis. Segundo Adário[4], merecem especial atenção
aplicações voltadas para: criptografia e compressão, casamento de padrões, ordenação,
simulação de sistemas físicos, processamento de vídeo e de imagens, aritmética especializada.
Para que se possa tirar proveito de uma implementação em arquitetura reconfigurável,
dois passos devem ser seguidos:
• Identificar, em um aplicação, a porção regular e a seção crítica ao desempenho;
• Avaliar as opções para o mapeamento da aplicação em dispositivos programáveis.
Esta consideração é deveras importante, pois a melhor implementação em uma arquitetura
reconfigurável pode ser muito diferente, no que tange ao estilo de programação,
de uma implementação baseada em GPP.
3.3.1 FPGA
Os FPGAs (Field-Programmable Gate Arrays) foram introduzidos no mercado em 1985
pela Xilinx e foram responsáveis pela grande expansão dos sistemas reconfiguráveis. Esses
dispositivos permitem a integração de lógica e memória em um único circuito, além de
serem programáveis, permitindo a reconfiguração do hardware e rápida prototipação de
sistemas digitais.
A estrutura básica do FPGA (figura 3.4) pode variar segundo o fabricante do mesmo,
mas são compostos, basicamente, dos seguintes recursos:
1. Funções lógicas programáveis de n entradas (blocos lógicos), onde n varia com a
família e fabricante do FPGA;
2. Rede de conexão para interligar entre os diversos blocos lógicos existentes;
3. Flip-flops ou registradores (blocos lógicos) para o armazenamento de informações;
4. Amplificadores de corrente de entrada e saída;
38

Figura 3.4: Estrutura interna de um FPGA.
5. Memória RAM interna nos dispositivos mais modernos.
FPGAs que possuem um pequeno número de poderosos blocos lógicos reconfiguráveis
são classificados como FPGAs com granulações grandes, enquanto que os que possuem
grande número de blocos lógicos simples, são classificados como FPGAs com granulações
pequenas [70]. Um único bloco lógico em um FPGA com grande granulação é capaz de
adicionar ou comparar dois números, enquanto que em um FPGA com granularidade fina
são necessários mais de um bloco lógico para efetuar as mesmas operações.
3.3.2 Síntese de sistemas reconfiguráveis
Os FPGAs são componentes bastante versáteis, capazes de implementar uma infinidade
de circuitos lógicos combinacionais e seqüenciais. Entretanto, a tarefa de transformar o
projeto de um circuito digital em um circuito mapeado na tecnologia de FPGA é bastante
complexa.
Além disso, os FPGAs possuem uma arquitetura interna que, embora possua um núcleo
comum, varia dentro de famílias de um mesmo fabricante e também entre fabricantes
diferentes. Devido a essa diversidade, uma outra tarefa difícil para o projetista é conhecer
todas essas arquiteturas internas e manipular seus elementos programáveis (EABs, CLBs
e interconexões) da forma mais otimizada para a arquitetura em questão.
Para automatizar os processos envolvidos nos projetos com esses dispositivos e abstrair
as dependências tecnológicas, diversas ferramentas foram criadas, algumas de uso geral
e outras dependentes da tecnologia de um particular fabricante. A grande utilização
dos FPGAs é devida ao suporte dado por esses programas de automação de projetos
eletrônicos.
Fluxo de projeto
O fluxo de projeto para FPGA pode ser dividido basicamente nas seguintes fases:
especificação do circuito, síntese, simulação e configuração do FPGA, como pode ser visto
39

na figura 3.5.
O projeto começa com a descrição do circuito. Nesta etapa pode-se optar por duas
metodologias de especificação, o desenho de um diagrama esquemático ou a utilização de
uma linguagem de descrição de hardware. A primeira abordagem normalmente requer ferramentas
proprietárias do fabricante do FPGA escolhida, prejudicando sua portabilidade.
Além disso, as alterações no projeto são mais complexas que nas linguagens de descrição.
Por esses motivos, deve ser evitada.
Figura 3.5: Fluxo de projeto utilizando FPGAs.
Para uma especificação baseada em linguagens de descrição de hardware, as linguagens
Verilog [18] e VHDL [10] são as mais utilizadas. Verilog é utilizado basicamente no mercado
americano, enquanto que a linguagem VHDL é um padrão mundial.
A etapa de síntese, em geral, é executada por uma ferramenta do fabricante do FPGA
escolhida, pois está intimamente ligada com sua arquitetura interna. Ela pode ser dividida
nas seguintes partes:
• otimização lógica: manipula as equações lógicas geradas na etapa inicial, visando
otimizar o circuito final;
• mapeamento tecnológico: consiste na transformação das equações lógicas otimizadas
em um circuito que utiliza os blocos lógicos presentes no FPGA alvo. Nesta fase
também são realizadas minimizações nas quantidades de blocos lógicos e caminho
crítico (caminho com maior atraso combinacional) do circuito;
• posicionamento: é definida a distribuição os blocos lógicos na matriz do FPGA. Para
isso, o arranjo dos blocos tenta minimizar o comprimento total das interconexões;
• roteamento: é quando ocorre a interligação dos blocos lógicos dispostos na matriz
do FPGA por intermédio da rede de interconexões programável.
40

A síntese, embora totalmente automatizada, permite a intervenção de projetistas experientes,
principalmente na fase de posicionamento, que é bastante crítica para a performance
geral do sistema.
Na fase de simulação é efetuado um teste da lógica do circuito descrito. Vários
estímulos são aplicados em suas entradas e depois é verificado o comportamento ou as
respostas obtidas para esses estímulos. Além disso, é possível verificar os atrasos internos,
ou seja, tempo que um sinal de saída leva para ser alterado após a transição de um sinal
de entrada, determinar caminhos críticos e a velocidade máxima de operação.
Já no processo de síntese, é gerado um arquivo de configuração do FPGA. Não sendo
descoberto nenhum problema durante a simulação, esse arquivo pode ser enviado para o
FPGA, de maneira que ele passe a operar de acordo com o circuito projetado. Como o
FPGA é volátil, o arquivo gerado pode ser armazenado em uma EEPROM (electrically
erasable programable read-only memory) permitindo que o FPGA se auto configure toda
vez que o circuito é ligado.
3.3.3 Linguagens de descrição de hardware e VHDL
No início dos anos 80, o departamento de defesa americano (DoD) estava preocupado
com a manutenção de seus equipamentos eletrônicos e em aumentar a produtividade dos
projetistas, devido aos constantes avanços tecnológicos que ocorrem na área. Além disso,
várias empresas forneciam equipamentos e desenvolviam projetos para governo.
No programa VHSIC (very high speed integrated circuits) foi feito um esforço de padronização
por uma linguagem que pudesse descrever a estrutura e funcionalidade dos
circuitos integrados, que fosse de fácil entendimento por qualquer projetista e possibilitasse
simulações dos circuitos nela descritos. Desse modo, projetos que utilizassem essa
linguagem poderiam ser facilmente migrados de uma tecnologia para outra, acompanhando
as evoluções do setor, e os projetos desenvolvidos para o DoD pelos diversos fornecedores
seriam padronizados e sua manutenção facilitada.
Esse esforço resultou na linguagem VHDL (VHSIC hardware description language) [42],
que passou a ser um padrão aceito pelo IEEE [1]. Como todos os padrões do IEEE, a
VHDL é revista a cada cinco anos, e em 1992, foi proposta uma versão revisada, adotada
em 1993 com o nome de IEEE-1164.
No início da década de 90, a VHDL foi usada primeiramente para projetos em ASIC
e foram desenvolvidas ferramentas para automatizar o processo de criação e otimização
das implementações. Na segunda metade da década, o uso de VHDL em síntese moveu-se
para a área de dispositivos lógicos programáveis (CPLDs e FPGAs).
VHDL possibilita descrições tanto em baixo nível (conexões entre componentes como
portas E, OU, etc.) quanto em nível mais abstrato de comportamento. Assim, as construções
em VHDL são divididas em três categorias, cada uma significando um nível diferente
de abstração:
41

• Comportamental: o circuito é definido na forma de um algoritmo, utilizando construções
similares àquelas de linguagens de programação;
• Fluxo de dados: tem-se a visão dos dados como um fluxo através do circuito, da
entrada até a saída. Uma operação é definida em termos de uma coleção de dados,
expressados como comandos concorrentes;
• Estrutural: a visão mais próxima do hardware. Um modelo onde os componentes
do circuito são instanciados e as ligações entre eles descritas.
Contudo, a maioria das ferramentas de síntese ainda não aceita descrições puramente
comportamentais, onde não se tem um relógio explícito, não se consegue inferir os registradores
e o conjunto de comandos é seqüencial, quase como um programa em linguagem
C. Assim, as descrições comportamentais, embora mais abstratas, devem levar em conta
diversos aspectos de um projeto de hardware para poderem ser sintetizadas corretamente.
A estrutura de um programa escrito em VHDL baseia-se em níveis hierárquicos. Resumidamente,
podemos definir 4 desses níveis:
• Pacotes: permite agregar em um projeto de vários componentes ou entidades previamente
definidos. Pode ser visto como uma “biblioteca” de componentes dentro de
um projeto. Aceita também definições de tipos e funções;
• Entidades: uma entidade é qualquer componente VHDL que tenha um conjunto de
portas de comunicação, com entradas e saídas. Uma entidade descreve um componente
como uma “caixa-preta”, ou seja, apenas suas portas de entrada e saída são
visíveis;
• Arquitetura: é um conjunto de primitivas em VHDL que farão a efetiva descrição do
hardware. É aqui que as abordagens comportamental, fluxo de dados ou estrutural
são definidas;
• Processos: é uma abstração de hardware que está sempre atuando. Um processo é
basicamente o modelo de um componente físico, que possui uma lista de sinais dos
quais depende (chamada de lista de sensitividade). Os processos podem ser síncronos
ou assíncronos e diversos deles podem ser definidos dentro de um arquitetura. Os
processos descritos em uma arquitetura são sempre concorrentes, mas o fluxo dentro
de um processo é seqüencial.
Outra característica importante da VHDL é que ela é uma linguagem fortemente tipada,
aceitando poucas conversões entre os tipos de dados aceitos.
Um programa escrito em VHDL possui o seguinte aspecto:
42

-- Uso de bibliotecas. A terceira cláusula use faz refer^encia a um pacote
-- chamado componentes
library IEEE;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;
use work.componentes.all;
-- Definiç~ao da entidade
entity MULT is
generic (size : integer := 16);
port (NUM1, NUM2 : in std_logic_vector(size-1 downto 0);
CLK, RST : in std_logic;
RES: out std_logic_vector(size*2-1 downto 0));
End MULT;
-- Definiç~ao da arquitetura
architecture CALC of MULT is
-- Definiç~ao de sinais internos
signal X,X1 : std_logic_vector(size downto 0);
begin
-- Definiç~ao de um processo síncrono
REG: process (CLK, RST)
Begin
if RST = ’1’ then
ESTADO

• a descrição da especificação do circuito serve como documentação e explicita os
objetivos do projeto;
• o uso da síntese melhora a produtividade;
• a padronização dessas linguagens resulta em portabilidade, tornando o código reutilizável
em diferentes ambientes de desenvolvimento.
Evidentemente, esse estilo de projeto não possui apenas vantagens. Alguns problemas
permanecem ou são criados pela utilização dessas linguagens:
• investimento inicial em educação e treinamento dos projetistas;
• a síntese é limitada e muitos problemas devem ser particionados à mão (mas, nesse
caso, seriam mais dificilmente resolvidos pelo projetista humano);
• não é solução para todo tipo de projeto;
• não atende a algumas restrições sérias, por exemplo, circuitos voltados ao baixo
consumo, uso de pipeline, etc;
• não existe (ainda) a síntese de circuitos analógicos e mistos.
3.4 Somadores
3.4.1 Meio-somador (half adder)
Executa a soma entre dois bits, gerando uma saída S dada pela soma desses dois bits
e uma saída V A que representa o “vai-um” dessa soma, segundo a tabela a seguir.
Tabela 3.1: Tabela-verdade do meio-somador (half adder).
A 0 B 0 V A0 S 0
0 + 0 = 0 0
0 + 1 = 0 1
1 + 0 = 0 1
1 + 1 = 1 0
Da tabela 3.1, obtêm-se as seguintes equações que descrevem a relação entre as entradas
e as saídas de um meio-somador:
S 0 = A 0 ⊕ B 0 e (3.1)
o que leva à implementação esquematizada na figura 3.6.
V A0 = A 0 · B 0 , (3.2)
44

Figura 3.6: Diagrama esquemático do meio-somador.
3.4.2 Somador completo (full adder)
Executa a soma entre três bits sendo um deles o “vem-um” recebido de um bit menos
significativo. Gera uma saída S dada pela soma desses bits e uma saída V que representa
o “vai-um” dessa soma.
A seguir, é apresentada a tabela-verdade que descreve o somador completo. Desta
tabela, são obtidas as equações 3.3 e 3.4 para as saídas do somador.
Tabela 3.2: Tabela-verdade do somador completo (full adder).
V E1 A 1 B 1 V A1 S 1
0 + 0 + 0 = 0 0
0 + 0 + 1 = 0 1
0 + 1 + 0 = 0 1
0 + 1 + 1 = 1 0
1 + 0 + 0 = 0 1
1 + 0 + 1 = 1 0
1 + 1 + 0 = 1 0
1 + 1 + 1 = 1 1
S 1 = V E1 ⊕ (A 1 ⊕ B 1 ), (3.3)
A equação 3.4 pode ainda ser reescrita como
V A1 = A 1 · B 1 + V E1 · (A 1 + B 1 ). (3.4)
o que conduz ao circuito esquematizado na figura 3.7.
V A1 = A 1 · B 1 + V E1 · (A 1 ⊕ B 1 ), (3.5)
3.4.3 Somador ripple carry
Para somarmos números com dois ou mais bits podemos utilizar o somador completo
obtido anteriormente e conectarmos os mesmos em cascata (um seguido do outro). Por
45

Figura 3.7: Diagrama esquemático do somador completo.
Figura 3.8: Diagrama de um somador ripple carry de 4 bits.
exemplo, para somarmos dois números (A + B) de quatro bits, montamos a estrutura
mostrada na figura 3.8.
No primeiro somador (de ordem 0, bit menos significativo) temos que fazer V 0 = 0 pois
não temos nenhum bit vindo de uma etapa anterior. Poderia também ter sido utilizado o
meio-somador para essa primeira etapa, já que ele não possui essa entrada de “vem-um”.
A saída “vai-um” de um somador de ordem n é conectada na entrada “vem-um” de
um somador de ordem n+1. Daí a origem do nome ripple carry, o “vai-um” (carry) vai
se propagando, a partir do primeiro somador (bit 0), até o último somador (bit mais
significativo).
Isso torna esse somador lento, já que o sinal V 4 (o “vai-um” do último somador) deve
aguardar o sinal V 3 , que por sua vez tem que aguardar o sinal V 2 e assim por diante.
Supondo que o atraso (tempo para que o sinal de saída se estabilize após uma variação
no sinal de entrada) de cada etapa seja de t, o sinal V 4 só estará estável após um tempo
de 4t. Para somadores de maior ordem (8, 16, 32 bits) esse atraso crescerá linearmente.
3.4.4 Somador com “vai-um” antecipado (carry look ahead)
Ao invés de esperar com que o sinal de “vai-um” (carry) se propague por todas as
etapas até a última e dado que os bits dos dois números a serem somados já estão estáveis
na entrada, pode-se estimar com antecedência o valor que a saída “vai-um” terá em cada
etapa.
Tomando por base a equação do sinal “vai-um” obtida no somador completo,
podemos escrever: V i+1 = A i · B i + V i · (Ai ⊕ Bi) ⇒ V i+1 = G i + P i · V i , onde G i = A i · B i
é designado generate carry e P i = (A i ⊕ B i ) é designado propagate carry. Assim, temos:
46

⎧
⎪⎨
⎪⎩
V 1 = G 0 + P 0 · V 0
V 2 = G 1 + P 1 · V 1 = G 1 + P 1 · G 0 + P 1 · P 0 · V 0
(3.6)
V 3 = G 2 + P 2 · V 2 = G 2 + P 2 · G 1 + P 2 · P 1 · G 0 + P 2 · P 1 · P 0 · V 0
V 4 = G 4 + P 3 · V 3 = G 3 + P 3 · G 2 + P 3 · P 2 · G 1 + P 3 · P 2 · P 1 · P 0 · V 0
Os sinais S i ’s, por sua vez, podem ser obtidos a partir dos sinais P i ’s gerados:
S i = V i ⊕ (A i ⊕ B i ) = V i ⊕ P i . (3.7)
A figura 3.9 ilustra um somador de 4 bits com “vai-um” antecipado.
Figura 3.9: Diagrama de um somador de 4 bits com “vai-um” antecipado.
Note que o último sinal de “vai-um” (V 4 ) exigiria em seu cálculo um tempo dado pelo
atraso da operação OU-Exclusivo (XOR) utilizada nos P i ’s (enquanto isso os Gi’s também
estariam sendo calculados), mais o atraso da operação E (AND) entre os P i ’s calculados
e finalmente o atraso da operação OU (OR). Esse tempo é praticamente igual ao tempo
que o somador completo leva para gerar em sua saída os sinais de soma e “vai-um”. Dessa
forma, o tempo de resposta desse somador é equivalente ao de apenas uma etapa do
somador anterior (ripple carry).
Note ainda que a adição de mais etapas não altera o tempo de resposta desse somador
já que os sinais V i ’s levam o mesmo tempo para serem calculados.
Entretanto, a adição de mais etapas torna a lógica combinacional desse somador extremamente
complexa. Assim, os somadores que utilizam esse esquema fazem uso de
“módulos” de 4 bits ligados em uma estrutura hierárquica. Cada módulo deve gerar os
sinais G G e P G , generate group e propagate group, respectivamente. Esses dois sinais nada
mais são do que o sinal V 4 desmembrado, sendo calculados como:
G G = G 3 + P 3 · G 2 + P 3 · P 2 · G 1 + P 3 · P 2 · P 1 · G 0 , e (3.8)
P G = P 3 · P 2 · P 1 · P 0 . (3.9)
A seguinte figura ilustra o diagrama de blocos de um somador carry look ahead de 16
bits:
47

Figura 3.10: Diagrama de um somador de 16 bits com “vai-um” antecipado.
A lógica combinacional utilizada nesse somador de 16 bits é a mesma utilizada em
cada um dos somadores de 4 bits.
3.4.5 Subtrator
Para construirmos um subtrator podemos aproveitar uma das propriedades das portas
XOR (OU-Exclusivo) de atuar como um inversor controlado e que uma subtração pode
ser efetuada através de uma soma se o número a ser subtraído estiver representado em
complemento de 2: A − B = A + (−B) = A + (B + 1) = A + B + 1.
O circuito abaixo pode somar ou subtrair dois números de 4 bits de acordo com o sinal
de controle C. Se C = 0, temos S = A + B e se C = 1, S = A − B (e despreza-se o
“vai-um” final).
Figura 3.11: Diagrama de um somador-subtrator de 4 bits.
3.5 Matrizes esparsas
Matrizes esparsas são aquelas que possuem uma grande quantidade de elementos iguais
a zero. Esse tipo de matriz pode ser mais eficientemente armazenada se apenas os elementos
diferentes de zero forem guardados.
Existem diversos métodos para efetuar esse armazenamento [63][19]. Nesses esquemas,
os elementos diferentes de zero são armazenados de forma contínua na memória e,
48

dependendo do método adotado, também uma limitada quantidade de zeros. Isto, é claro,
requer uma forma de saber como os elementos armazenados se encaixam na matriz completa.
Essas diversas formas de armazenamento também permitem que operações sobre
matrizes (soma, multiplicação) sejam efetuadas diretamente sobre a matriz reduzida, sem
a necessidade de se restaurar a matriz completa.
3.5.1 Compressed Row Storage (CRS)
É o método mais geral de armazenamento junto com o CCS. Ele não efetua nenhuma
suposição acerca da estrutura da matriz esparsa, mas também não armazena nenhum
elemento desnecessário. Por outro lado, não é muito eficiente, precisando de passos adicionais
(endereçamento indireto) quando se efetuam operações (multiplicação de matrizes,
por exemplo) sobre a forma reduzida obtida.
Dada uma matriz A i,j esparsa e assimétrica, definimos nnz como a quantidade de
elementos diferentes de zero em A. Nesse método, são criados 3 vetores: val, col ind
e lin ptr. O vetor val, com comprimento igual a nnz, contém os elementos diferentes
de zero da matriz A, na seqüência em que aparecem em cada linha, linha por linha. O
vetor col ind guarda um índice da coluna na qual se encontra cada elemento armazenado
em val (se val(k) = A i,j , então col ind(k) = j). Dessa forma, col ind possui o mesmo
comprimento que val. Finalmente, o vetor lin ptr armazena a posição dos elementos em
val que iniciam uma nova linha e possui um comprimento igual ao número de linhas da
matriz mais 1.
A economia de espaço obtida por esse esquema é razoável se houver uma grande
quantidade de zeros na matriz esparsa. Supondo uma matriz quadrada, ou seja, i = j = n,
ao invés de serem armazenados n 2 elementos, são necessários 2nnz + n + 1 elementos.
Como um exemplo, considere-se a matriz 5x5 dada por:
nesse caso, tem-se:
⎛
A =
⎜
⎝
10 0 0 −2 0
3 9 0 0 3
0 7 8 0 0
4 0 0 8 0
0 4 0 2 1
⎞
; (3.10)
⎟
⎠
val = [ 10 −2 3 9 3 7 8 4 8 4 2 1 ] , (3.11)
col ind = [ 1 4 1 2 5 2 3 1 4 2 4 5 ] e (3.12)
lin ptr = [ 1 3 6 8 10 13 ] . (3.13)
49

3.5.2 Compressed Column Storage (CCS)
Esse método é idêntico ao CRS, exceto que as colunas de A são armazenadas ao invés
das linhas. Em outras palavras, o formato CCS é igual ao CRS aplicado em A t .
Similarmente ao CRS, são criados 3 vetores: val, lin ind e col ptr, onde val armazena
os elementos diferentes de zero de A, lin ind é um índice das linhas na qual se encontram
os valores guardados em val e col ptr indica qual elemento de val inicia uma nova coluna.
Para a mesma matriz A exemplificada na descrição do método CRS, obtemos:
val = [ 10 3 4 9 7 4 8 −2 8 2 3 1 ] , (3.14)
lin ind = [ 1 2 4 2 3 5 3 1 4 5 2 5 ] e (3.15)
col ptr = [ 1 4 7 8 11 13 ] . (3.16)
3.5.3 Compressed Diagonal Storage (CDS)
Se a matriz esparsa concentrar os valores diferentes de zero em uma faixa em torno de
sua diagonal principal, então é mais interessante aproveitar essa estrutura no esquema de
armazenagem.
No CDS, as subdiagonais da matriz esparsa são armazenadas em posições consecutivas
de memória, não sendo necessários os vetores de identificação de linha e coluna. A matriz
reduzida obtida é também mais eficiente nas operações de multiplicação.
Entretanto, nesse esquema podem ser armazenados alguns elementos iguais a zero da
matriz original. Além disso, o formato CDS irá introduzir alguns zeros na matriz reduzida
que nem fazem parte da matriz esparsa, mas necessários para identificar a posição original
dos elementos armazenados.
Aplicando o CDS na matriz assimétrica e esparsa dada por
obtemos:
⎛
A =
⎜
⎝
10 −3 0 0 0
3 8 2 0 0
0 4 9 7 0
0 0 0 6 1
0 0 0 5 2
⎞
, (3.17)
⎟
⎠
val(−1) = [ 0 3 4 0 5 ] , (3.18)
val(0) = [ 10 8 9 6 2 ] e (3.19)
50

3.5.4 Jagged Diagonal Storage (JDS)
val(1) = [ −3 2 7 1 0 ] . (3.20)
Esse formato é bastante útil na implementação de métodos iterativos em processadores
paralelos ou vetoriais. Similarmente ao CDS, os vetores obtidos possuem o mesmo comprimento
da matriz esparsa. Se os valores diferentes de zero não estiverem bem concentrados
em torno da diagonal principal, o JDS é mais espaço-eficiente do que o CDS.
Para se obter a matriz reduzida, na forma simplificada do JDS, os elementos diferentes
de zero são deslocados para a esquerda e depois as colunas são armazenadas de forma
consecutiva na memória. Como as colunas podem não ter o mesmo tamanho, alguns zeros
são inseridos para que todos os vetores resultantes possuam o mesmo comprimento. Após
essas transformações na matriz original, são obtidos os vetores contendo os elementos
diferentes de zero e os zeros inseridos (val) e os índices das colunas na qual os elementos
pertenciam antes da transformação (col ind).
Como um exemplo, temos:
⎛
A =
⎜
⎝
10 0 −3 0 0
3 0 8 2 0
1 4 9 7 0
0 0 0 6 1
0 0 5 0 2
⎞
⎛
→
⎟ ⎜
⎠ ⎝
10 −3
3 8 2
1 4 9 7
6 1
5 2
⎞
⎛
→
⎟ ⎜
⎠ ⎝
10 −3 0 0
3 8 2 0
1 4 9 7
6 1 0 0
5 2 0 0
⎞
, (3.21)
⎟
⎠
sendo obtidos:
⎧
⎪⎨
⎪⎩
⎧
⎪⎨
⎪⎩
val(1) = [ 10 3 1 6 5 ]
val(2) = [ −3 8 4 1 2 ]
val(3) = [ 0 2 9 0 0 ] e (3.22)
val(4) = [ 0 0 7 0 0 ]
col ind(1) = [ 1 1 1 4 3 ]
col ind(2) = [ 3 3 2 5 5 ]
col ind(3) = [ 0 4 3 0 0 ] . (3.23)
col ind(4) = [ 0 0 5 0 0 ]
Fica claro que esse método não é muito eficiente se a quantidade de zeros não for
grande ou se as linhas da matriz esparsa não possuírem praticamente a mesma quantidade
de elementos diferentes de zero.
51

Capítulo 4
DESCRIÇÃO DA IMPLEMENTAÇÃO
4.1 Aplicação de Estruturas Paralelas na comparação
de seqüências
Para a comparação de seqüências baseadas no algoritmo de Needleman e Wunsch,
as soluções computacionais seqüenciais não oferecem um bom desempenho, mesmo com
processadores mais velozes, pois este algoritmo tem complexidade de tempo quadrática,
conforme visto no capítulo 2. Portanto, a computação paralela tem sido empregada na
tentativa de reduzir o tempo de execução desses algoritmos.
Com n processadores paralelos, é possível aumentar a velocidade de processamento
por um fator n, desde que o algoritmo estritamente seqüencial usado possa ser reescrito
por operações paralelas simultâneas. Como a comparação de seqüências é baseada em
computações análogas para cada posição de um vetor linear, pode-se conjecturar que
algoritmos paralelos mais eficientes possam ser elaborados para problemas de comparação
de seqüências.
Existem basicamente duas formas de aplicar paralelismo ao problema de comparação
de seqüências [34]:
• Paralelizando a operação de comparação: neste caso, todos os processadores cooperam
para determinar o escore de cada célula da matriz de similaridades. Como a
granularidade é mais fina, o número de comunicações é maior;
• Paralelizando o processo de comparação: neste caso, cada processador realiza um
número de comparações de forma independente, ou seja, calcula o escore das células
de porções menores das seqüências comparadas. Como a granularidade é mais grossa,
as demandas de comunicação são reduzidas. No entanto, o desempenho dependerá
de quão balanceada estiver a distribuição da carga de trabalho.
O segundo método é o método mais utilizado, porém o primeiro método é mais apropriado
para computadores SIMD onde todos os processadores executam a mesma instrução
ao mesmo tempo, e a velocidade de comunicação é rápida quando comparada à de processamento.
Sistemas SIMD geralmente possuem centenas de processadores lentos, mas
52

com baixo custo de comunicação. Essa é um tipo de arquitetura na qual as estruturas
sistólicas se encaixam totalmente.
O segundo método é mais adequado para MIMD, onde cada processador é significativamente
mais poderoso que um processador SIMD, e os processadores executam suas
instruções de forma independente, em vez de cooperarem para comparar cada seqüência
do banco de dados.
4.2 Dependência de Dados
Pela relação de recorrência do algoritmo de Smith-Waterman com penalidade constante
para os espaços (equação 2.4), pode-se observar que podemos computar s i,j se s i,j−1 ,
s i−1,j−1 e s i−1,j tiverem sido computados. Assim, o cálculo do valor de cada célula da
matriz de similaridades depende apenas da célula da linha e coluna anteriores (mesma
diagonal), da célula da mesma linha e coluna anterior (célula à esquerda) e da célula da
linha anterior e mesma coluna (célula acima).
Uma forma de paralelizar o cálculo da matriz respeitando-se essas dependências de
dados é calcular antidiagonal por antidiagonal, uma vez que elementos em uma antidiagonal
só dependem das antidiagonais previamente calculadas. A esse tipo de computação
paralela dá-se o nome de computação em onda [69] (figura 4.1).
Figura 4.1: Paralelização do cálculo da matriz de similaridade.
4.3 Plataforma Utilizada
Para o desenvolvimento do projeto foi utilizada a placa APEX PCI Development Board
do fabricante Altera, contendo o FPGA APEX EP20K400EFC672. Essa placa está instalada
em um computador da Dell com processador Pentium IV. A ferramenta de síntese
adotada foi o Quartus II da própria Altera.
4.4 Descrição Geral
A implementação realizada neste trabalho foi baseada no algoritmo de comparação local
de duas seqüências proposto por Smith-Waterman, utilizando a equação de recorrência
com penalidade constante para os espaços (equação 2.4), conforme descrito no capítulo 2.
53

Seja comparar e obter os melhores alinhamentos de duas seqüências: a seqüência de
consulta sendo CATAAGGCT e a seqüência do banco de dados sendo ACATAGGCAT.
Aplicando a equação de recorrência do algoritmo de Smith-Waterman (equação 2.4) a
essas seqüências, obtém-se a seguinte matriz de similaridade (figura 4.2), com a origem de
cada valor indicada por uma seta. Essas setas também indicam o caminho a ser percorrido
para se obter os alinhamentos. Os valores assinalados com um círculo serão posteriormente
explicados.
Figura 4.2: Matriz de similaridade para as seqüências ACATAGGCAT e CATAAGGCT.
4.4.1 Estrutura sistólica
Nas diversas implementações analisadas na revisão bibliográfica do capítulo 1, ficou
claro que a melhor abordagem para paralelizar em hardware o problema da comparação
de seqüências utilizando programação dinâmica era a utilização de estruturas sistólicas.
A utilização de um vetor sistólico permite dois tipos de mapemanto do problema: a
emulação das diagonais e a emulação das colunas (figura 4.3). No primeiro tipo, cada
célula do vetor é responsável pelo cálculo de uma das diagonais da matriz. Para duas
seqüências com comprimentos n e m, a matriz de similaridade irá possuir n + m − 1
diagonais. Dessa forma, essa é a quantidade de células necessárias para o vetor sistólico
com essa abordagem. Além disso, o vetor deve ser bidirecional e as seqüências a serem
comparadas devem ser deslocadas a partir de extremidades opostas em direção ao centro
do vetor.
Para o segundo tipo, cada célula do vetor é responsável pelo cálculo de uma coluna
da matriz de similaridade. Nesse mapeamento, o vetor pode ter o comprimento da menor
54

Figura 4.3: Tipos de emulação da matriz de similaridade.
das seqüências e seu sentido é unidirecional.
Pelos motivos expostos, a estratégia adotada foi a construção de uma estrutura
sistólica linear unidirecional. Nessa abordagem, de acordo com o exposto, cada elemento
de processamento do vetor sistólico é responsável pelo cálculo de uma das colunas
da matriz de similaridade. A principal razão para a escolha feita é que o tamanho da
estrutura (quantidade de elemento de processamento) depende apenas da seqüência de
consulta, não dependendo da seqüência do banco de dados, podendo essa ter qualquer
tamanho (na verdade, a memória do sistema é que irá limitar o tamanho da seqüência do
banco de dados).
Conforme já discutido no capítulo 1, o paralelismo obtido com a utilização de uma
estrutura linear sistólica reduz a complexidade de tempo do algoritmo de Smith-Waterman
de O(n × m) para O(n + m), ou seja, transforma-se um tempo quadrático em linear.
Para implementar o vetor sistólico, a cada base da seqüência de consulta deve corresponder
um elemento de processamento. Com isso, a seqüência de consulta pode ficar
armazenada dentro do vetor. Já a seqüência proveniente do banco de dados é deslocada,
da esquerda para a direita, para dentro da estrutura sistólica de forma a atravessá-la. A
cada ciclo de relógio, as bases da seqüência do banco de dados deslocam uma posição e o
cálculo de uma antidiagonal da matriz de similaridade é efetuado segundo o esquema da
figura 4.4.
Para o exemplo anterior, cuja seqüência de consulta é CATAAGGCT e a seqüência do
banco de dados é ACATAGGCAT, a estrutura sistólica resultante seria:
Note que a seqüência proveniente do banco de dados entra no vetor sistólico de maneira
invertida, de modo que o primeiro elemento dessa seqüência possa ser comparado com o
primeiro elemento da seqüência de consulta.
Elemento de processamento do vetor sistólico
Uma estrutura sistólica é composta por inúmeras instâncias de uma unidade menor
55

Figura 4.4: Estrutura linear sistólica uniderecional.
conhecida como elemento de processamento. Essas unidades são responsáveis por todo
o processamento efetuado dentro do sistema sistólico. Assim, o correto planejamento
dessas unidades é de vital importância para que a estrutura sistólica obtida possa ter o
desempenho e a simplicidade esperada.
Critérios utilizados
Para o projeto dos elementos de processamento (células) da estrutura sistólica foram
inicialmente estabelecidos os seguintes critérios que eles deveriam atender:
i. conseguirem aplicar a equação de recorrência (equação 2.4) do algoritmo de Smith-
Waterman;
ii. serem o mais simples possível para que utilizem poucos recursos da FPGA e, com
isso, caibam uma quantidade maior de células dentro do dispositivo. Assim, se
houver duas ou mais possibilidades de implementar um mesmo circuito, o mais
simples será o escolhido em relação ao mais rápido, desde que o impacto não seja
grande na performance;
iii. possuírem uma memória local para armazenar temporariamente os cálculos efetuados.
Mais tarde, verificou-se que somente esses critérios não eram suficientes e um acréscimo
foi feito a essa lista:
i. conseguirem aplicar as estratégias para minimizar a utilização da memória interna
(essas estratégias serão analisadas posteriormente);
ii. prover mecanismos de entrega dos dados calculados e armazenados para uma memória
externa.
56

Foi feita uma descrição inicial em VHDL do elemento de processamento baseada nos
critérios iniciais (i, ii e iii) com enfoque principal no critério ii. Posteriormente, adequou-se
o elemento de processamento para que os critérios iv e v também pudessem ser atendidos.
Estrutura interna
De acordo com a equação 2.4, o cálculo do valor de cada célula da matriz de similaridades
depende apenas da célula da linha e coluna anteriores (mesma diagonal), da célula
da mesma linha e coluna anterior (célula à esquerda) e da célula da linha anterior e mesma
coluna (célula acima). Dessa forma, para que essa equação possa ser aplicada dentro do
elemento de processamento, esses três valores devem estar presentes dentro da célula no
instante do cálculo.
Foi notado que o elemento de processamento necessitava armazenar apenas o valor da
diagonal e da linha superior. O valor da coluna à esquerda viria da célula adjacente como
resultado do cálculo feito no ciclo de relógio anterior. A estrutura inicial do elemento de
processamento pode ser vista na figura 4.5.
Figura 4.5: Estrutura interna inicial do elemento de processamento.
A seqüência de consulta está armazenada no vetor sistólico, com cada célula desse vetor
correspondendo a uma base dessa seqüência (B C ). Em um dado momento, após um ciclo
de relógio, uma nova base da seqüência do banco de dados (B BD ) entra no elemento de
processamento, proveniente da célula adjacente à esquerda. Essa célula também fornece
o valor da coluna à esquerda (c). Nesse mesmo instante, os valores da diagonal (a) e da
linha superior (b) também estão armazenados no elemento de processamento, após terem
sido gerados internamente e guardados no mesmo pulso de relógio que deslocou a base da
seqüência do banco de dados para dentro da célula.
Com isso, o elemento de processamento possui em seu interior todos os requisitos para
aplicar a equação de recorrência do algoritmo. O novo valor calculado (d) da matriz de
similaridade é fornecido para uma memória externa e ao mesmo tempo serve como base
para um novo cálculo que será feito por sua célula vizinha à direita.
Fluxo dos dados em seu interior
57

A dinâmica de como esses dados são gerados pode ser melhor visualizada com o auxílio
da figura 4.6. Para simplificar a análise, o valor fornecido pela célula adjacente à esquerda
foi colocado dentro do elemento de processamento, ao lado da base da seqüência do banco
de dados (G2).
Figura 4.6: Fluxo interno dos dados dentro do elemento de processamento.
No instante t, conforme descrito anteriormente, a célula de processamento possui todos
os elementos necessários para o cálculo de um novo valor da matriz de similaridade (esse
valor é calculado por intermédio de uma lógica combinacional a ser explicada). Após o
pulso de relógio, instante t + 1, o dado recebido da célula adjacente à esquerda (2) passa
a ser o novo valor diagonal do elemento de processamento. O valor calculado dentro do
elemento de processamento (0) passa a ser o novo valor da linha superior e também segue
junto com a base da seqüência do banco de dados (G) para a célula da direita. Ainda nesse
instante, a base da seqüência do banco de dados que estava na célula adjacente à esquerda
(A) é deslocada para o interior do elemento de processamento em questão, juntamente
com o valor calculado nessa célula (1), que será o novo valor da coluna à direita.
A figura 4.7 (baseada no trecho final da matriz de similaridade da figura 4.2) ilustra
essa dinâmica para várias células de processamento, mostrando o fluxo dos dados dentro
do vetor sistólico.
Figura 4.7: Dinâmica do sistema para vários elementos de processamento.
Note que a saída da última célula do vetor sistólico não é utilizada por nenhuma outra
célula. Entretanto, essa saída contém uma base da seqüência do banco de dados e o último
valor calculado para a linha dessa base. Assim, para o exemplo em questão, teríamos o
seguinte resultado a cada pulso de relógio: C3, A4 e T4. Veremos posteriormente que essas
saídas irão permitir ligar duas implementações em cascata (a saída de uma alimentando a
entrada da outra) permitindo que seqüências de consulta maiores possam ser utilizadas.
58

Lógica combinacional
Para a lógica combinacional que calcula o novo valor da matriz de similaridade dentro
do elemento de processamento, várias abordagens foram testadas para que ela ficasse o
menor e mais simples possível.
Na aplicação da equação de recorrência (equação 2.4), valores fixos (1, −1 e −2) são
somados aos valores armazenados na célula. Como essas operações devem ser efetuadas
em paralelo, mais de um somador é necessário, não sendo possível o reaproveitamento de
um único somador.
Além disso, os resultados parciais obtidos devem ser comparados para a obtenção de
um novo valor para a matriz de similaridade. Assim, as principais operações feitas na
aplicação da equação de recorrência são somas e comparações, devendo essas operações
serem tratadas de forma mais minuciosa.
Somadores e comparadores
Um somador que “incorporasse” a constante a ser utilizada seria mais simples que
um somador genérico. A desvantagem dessa estratégia é que o circuito gerado, embora
mais simples, ficaria restrito. Para um outro esquema de pontuação para a equação de
recorrência, uma nova descrição do somador teria que ser feita.
Das abordagens clássicas de somadores vistas no capítulo 3, o somador carry look ahead
foi descartado devido à sua complexidade combinacional. Assim, preferiu-se optar pelo
somador ripple carry já que a quantidade de bits a serem somados não seria grande e,
principalmente, pelo critério ii . O primeiro teste, somador com a constante embutida,
foi feito utilizando a constante −2 em sua notação em complemento de 2 com 8 bits:
111111110 (na ordem B 7 B 6 B 5 . . . B 0 ). Para o bit 0 do somador de 8 bits, pode ser utilizado
o meio somador pois não temos o sinal de “vem-um”. Pela tabela-verdade do meio somador
analisada no capítulo 3 (com o bit A n dessa tabela vindo do valor armazenado na célula
de processamento e o bit B 0 da constante −2), sendo o bit B 0 sempre igual a zero, uma
rápida observação nos leva ao seguinte resultado: S 0 = A 0 e V A0 = 0.
Como V A0 = 0, a tabela-verdade do meio somador pode ser novamente utilizada para
o segundo bit desse somador. Sendo o valor de B 1 = 1, temos a seguinte simplificação:
S 1 = Ā1 e V A1 = A 1 .
Para os demais bits do somador (S 2 a S 7 ), teremos o valor de B N sempre igual a 1.
Assim, simplificando a tabela-verdade do somador completo para essa situação, obtemos:
S N = ĀN · ¯V EN + A N · V EN (não-ou-exclusivo) e V AN = A N + V EN , com N variando de 2
a 7.
O circuito final do somador de 8 bits com a constante −2 embutida no mesmo pode ser
visto na figura 4.8. Esse circuito é bem mais simples que o demonstrado no capítulo 3. O
59

último sinal de “vai-um” foi mantido para indicar se o resultado da operação foi positivo
ou negativo.
Figura 4.8: Somador de 8 bits com a constante -2 embutida no mesmo.
Para a implementação desse somador de 8 bits em VHDL foi utilizada uma descrição
estrutural. Entretanto, após descrito o elemento de processamento utilizando essa simplificação
e comparando com o resultado de uma descrição em um nível mais alto (simplesmente
A − 2, sendo A um vetor lógico de 8 bits), verificou-se que não houve ganho
algum. A quantidade de elementos lógicos utilizados da FPGA foi a mesma para as duas
abordagens, como também o atraso necessário para efetuar essa operação.
Testes com as constantes +1 e −1 levaram ao mesmo resultado, ou seja, sem diferença
nos recursos utilizados na FPGA.
Como a ferramenta de síntese também faz uma análise lógica do sistema que está sendo
descrito, a explicação para tal fato é que a ferramenta efetuou as mesmas simplificações
feitas manualmente no circuito.
Com os comparadores, os testes feitos também tiveram o mesmo resultado. Os projetos
em nível de portas lógicas resultaram na mesma utilização de recursos que circuitos
descritos em níveis mais abstratos (A = B ou A > B). Dessa forma, optou-se por fazer
as implementações dos somadores e comparadores em um nível mais alto, deixando a descrição
em VHDL mais genérica e permitindo que outros esquemas de pontuação possam
vir a ser implementados com a simples substituição das constantes utilizadas.
Além da necessidade de se otimizar o circuito dos somadores e comparadores, era
também preciso otimizar a quantidade utilizada desses elementos dentro da célula de
processamento. O resultado dos testes anteriores mostrou também que os comparadores
são menos onerosos (menor quantidade de recursos utilizados) que os somadores. Assim,
quando possível, foi dada preferência para a utilização de um comparador no lugar de um
somador.
No cálculo de um novo valor da matriz de similaridade, o valor da diagonal é somado
com 1 ou −1 se as bases comparadas das duas seqüências forem iguais ou diferentes,
respectivamente. Essas operações podem ser implementadas de duas formas, de acordo
com a figura 4.9.
A implementação 1 utiliza dois somadores, um comparador e um multiplexador, en-
60

Figura 4.9: Cálculo do valor da diagonal.
quanto que a implementação 2 utiliza um somador, um comparador e um multiplexador.
Independente da quantidade de recursos internos da FPGA requerida pelo somador e
comparador, a implementação 2 é mais otimizada que a 1. Entretanto, a implementação
1 é um pouco mais rápida que a 2, pois no circuito 1 as somas e a comparação estão
sendo feitas simultaneamente, enquanto que na implementação 2 o multiplexador tem que
aguardar o resultado da comparação antes de definir qual será o valor fornecido ao somador.
Como a diferença de performance é baixa e o principal critério é o da economia, o
circuito 2 foi o escolhido. A esse resultado parcial, foi dado um nome interno de RES1.
Já os valores da coluna anterior e da linha superior são somados com -2 e esses dois
resultados, juntamente com o resultado anterior (RES1) e o 0 são comparados para definir
o novo valor da matriz de similaridade. Ao invés de comparar esses quatro valores simultaneamente
para selecionar o maior de todos, podemos comparar os resultados parciais
dois a dois e com uma nova comparação definir o resultado final.
Uma dessas comparações parciais pode ser obtida de acordo com uma das implementações
mostrada na figura 4.10. A esse novo resultado parcial foi dado o nome de
RES2.
Figura 4.10: Cálculo do valor relativo à inserção do espaço.
Novamente, a implementação 2 se mostrou mais eficiente no aspecto de utilizar recursos
da FPGA, embora a 1 seja um pouco mais rápida. Como as operações RES1 e RES2 são
feitas em paralelo, os atrasos das duas implementações não são somados. Além disso, a
lógica combinacional de uma célula não precisa aguardar o resultado da célula anterior
para efetuar o seu processamento. A cada ciclo de relógio todos os valores necessários para
a aplicação da equação de recorrência estão contidos na célula. Desse modo, as operações
61

RES1 e RES2 além de serem feitas em paralelo dentro de uma mesma célula, são feitas em
paralelo por todas as células. Pelo exposto, a escolha das implementações mais simples
para esses cálculos parciais não irá acarretar em uma perda notável na velocidade de
processamento da estrutura sistólica proposta.
Finalmente, para se gerar o resultado final da equação, basta comparar RES1, RES2
e 0, selecionando o maior dos três valores. Isso pode ser feito com um comparador e um
multiplexador. Entretanto, objetivando otimizar a saída de dados para a memória, uma
outra abordagem foi escolhida.
Após toda essa análise, percebe-se que o elemento de processamento é essencialmente
combinacional. Os flip-flops utilizados (onde são armazenados os valores na célula de
processamento) servem apenas como uma barreira temporal para que as operações possam
ser efetuadas sem interferência. Assim, não foi necessário descrever uma máquina de
estados [28] para controlar o fluxo do processamento, tornando a estrutura sistólica ainda
mais simples.
Saída para a memória externa
Conforme os valores da matriz de similaridade vão sendo calculados, nas regiões onde
as duas seqüências são similares, esses valores vão aumentando gradativamente. Se as
duas seqüências forem praticamente iguais e com a pontuação utilizada na equação 2.4, o
valor final da matriz de similaridade será bem próximo do comprimento dessas seqüências.
Como as seqüências são grandes, a quantidade de bits necessária para representar esses
valores também será grande. Para seqüências relativamente pequenas, com 1.000 bases,
já seriam necessários 10 bits para essa representação.
Com a matriz de similaridade montada, ainda é necessário efetuar um percorrimento
reverso (backtracking) para se obter os alinhamentos. Nesse percorrimento, é preciso
descobrir quais dos três valores adjacentes originou o dado corrente. Conforme visto no
capítulo 2, a origem de cada valor da matriz pode ser identificada por um vetor, permitindo
que o percorrimento reverso possa ser feito baseado nesses vetores (ou ponteiros).
Como os vetores podem ser representados em um comprimento fixo, optou-se por
armazená-los na memória externa ao invés dos valores calculados para a matriz, que iriam
exigir uma grande quantidade de bits e que dependeriam do comprimento das seqüências
comparadas. Além disso, o armazenamento do vetor acelera o processo do percorrimento
reverso.
A princípio, dois bits poderiam representar os três vetores possíveis. No entanto, um
valor gerado na matriz de similaridade pode ter mais de uma origem. Para esgotar todas
as possibilidades, a representação desses vetores deve utilizar três bits. A figura 4.11
mostra como pode ser feita essa codificação.
Cada bit da representação indica um sentido. Assim, um valor da matriz cuja origem
62

Figura 4.11: Codificação dos vetores da matriz de similaridade.
foi o elemento da diagonal, seria representado por 010, ou seja, apenas com o bit V2
setado. Um valor cuja origem foi a diagonal e a linha superior seria representado por 011.
Para um vetor nulo, que indicaria o final de uma seqüência, todos os bits estariam em 0.
O início de um alinhamento se dá quando o valor calculado para a matriz de similaridade
ultrapassa um certo limite considerado como ótimo. Como o valor calculado não está
sendo mais fornecido externamente, era necessário indicar quando esse limite havia sido
alcançado e/ou ultrapassado. Assim, foi adicionado um bit na estrutura de representação
do vetor para essa indicação. O valor limite utilizado para indicar se um alinhamento deve
ser recuperado é passado ao vetor sistólico como um parâmetro na compilação do código.
Com base nessa representação, o dado gerado para a memória externa possuía inicialmente
4 bits, independente do tamanho das seqüências comparadas. Posteriormente, esse
tamanho teve que ser aumentado para que algumas otimizações pudessem ser efetuadas.
Geração dos vetores
Para saber a origem de um novo valor calculado para a matriz de similaridade era
preciso efetuar alguns testes com os resultados parciais obtidos anteriormente. Até esse
ponto, dois resultados parciais estavam disponíveis, RES1, originado pela aplicação da
equação de recorrência ao elemento da diagonal, e RES2, originado pela aplicação da
equação de recorrência ao maior valor dentre os valores da coluna à esquerda e da linha
superior.
Para que os bits V3, V2 e V1, representando uma seta à esquerda, uma seta diagonal
e uma seta para cima, respectivamente, indicassem corretamente a origem do valor calculado,
levando-se em conta que ela pode não ser única, as seguintes funções lógicas foram
estabelecidas:
- V1: se os resultados RES1 e RES2 forem positivos e RES1 for menor ou igual a
RES2 e o valor da linha superior for maior ou igual ao da coluna à esquerda ou se
RES1 for negativo e RES2 positivo e o valor da linha superior for maior ou igual ao
da coluna à esquerda;
- V2: se os resultados RES1 e RES2 forem positivos e RES1 for maior ou igual a
RES2 ou se o resultado RES1 for positivo e RES2 negativo;
- V1: se os resultados RES1 e RES2 forem positivos e RES1 for menor ou igual a
RES2 e o valor da linha superior for menor ou igual ao da coluna à esquerda ou se
63

RES1 for negativo e RES2 positivo e o valor da linha superior for menor ou igual ao
da coluna à esquerda.
Com RES1 e RES2 negativos, os bits V1, V2 e V3 serão iguais a zero, indicando um
vetor nulo. Para que essas funções lógicas pudessem ser mapeadas, vários sinais lógicos
(flags) tiveram que ser definidos dentro do elemento de processamento:
- SIN0: ativo em 1 quando o resultado parcial RES1 é maior ou igual a zero;
- SIN1: ativo em 1 quando o resultado parcial RES2 é maior ou igual a zero;
- FLGD: ativo em 1 quando RES1 é maior que RES2;
- FLGH: ativo em 1 quando o valor da coluna à esquerda é maior que o da linha
superior;
- FLGI1: ativo em 1 quando o valor da coluna à esquerda é igual ao da linha superior;
- FLGI2: ativo em 1 quando os resultados parciais RES1 e RES2 são iguais.
Além disso, para cada um desses sinais, também foi definido o seu complementar:
NSIN0, NSIN1, NFLGD, NFLGH, NFLGI1 e NFLGI2. Alguns testes mostraram que
definir um sinal complementar consumia menos recursos do que ficar negando (invertendo)
o sinal original.
Com a definição desses sinais, as funções lógicas dos bits V1, V2 e V3 foram mapeadas
da seguinte forma:
- V1: SIN0·SIN1·NFLGD·NFLGH + NSIN0·SIN1· NFLGH;
- V2: SIN0 ·SIN1·FLGD + SIN0·SIN1·FLGI2 + SIN0 · NSIN1;
- V3: SIN0·SIN1·NFLGD·FLGH + SIN0·SIN1· NFLGD·FLGI1 + NSIN0·SIN1· FLGH
+ NSIN0 ·SIN1·FLGI1.
Na definição dessas funções lógicas tomou-se o cuidado de não utilizar os sinais FLGD e
NFLGD quando um dos resultados parciais RES1 e RES2 fosse negativo. Na representação
em complemento de 2, um número negativo possui seu bit mais significativo em 1. Assim,
um comparador binário gera resultados incorretos quando dois números de sinais opostos
são comparados.
Aplicando as técnicas de simplificação da álgebra de Boole [28], podemos reduzir essas
funções lógicas para:
- V1: SIN1 · NFLGH · (NSIN0 + NFLGD);
- V2: SIN0 · (NSIN1 + FLGD + FLGI2);
64

- V3: SIN1 · (NSIN0 + NFLGH) · (FLGH + FLGI1).
Seleção do valor final da matriz de similaridade
Quando os resultados parciais RES1 e RES2 foram obtidos, foi visto que o novo valor
calculado da matriz de similaridade seria o maior dentre esses dois valores e o 0. Para
essa seleção, poderia ser utilizado um comparador e um multiplexador.
Acontece que um dos valores a serem selecionados é o 0. Assim, podemos “fundir” o
comparador e o multiplexador e criar uma função lógica que indique se o valor de RES1
deve ser o escolhido ou então RES2. Se nenhum deles for selecionado, a função lógica
automaticamente irá gerar o 0 como resultado final.
Dois novos sinais foram criados, MUX0 e MUX1, para selecionar os resultados parciais
RES1 e RES2, respectivamente. Dessa forma, o valor final gerado pode ser obtido pela
seguinte função lógica: VF = MUX0 · RES1 + MUX1 · RES2.
O sinal MUX0 deve ser ativado quando os resultados RES1 e RES2 forem positivos e
RES1 for maior ou igual a RES2 ou se o resultado RES1 for positivo e RES2 negativo.
Já o sinal MUX1 deve ser ativado quando os resultados RES1 e RES2 forem positivos e
RES1 for menor ou igual a RES2 ou se o resultado RES1 for negativo e RES2 positivo.
Aproveitando os sinais de geração dos vetores, podemos definir as seguintes funções
lógicas, já simplificadas, para os sinais MUX0 e MUX1:
- MUX0: SIN0 ”(NSIN1 + FLGD + FLGI2);
- MUX1: SIN1 ”(NSIN0 + NFLGH).
Note que o sinal V2 é idêntico ao sinal MUX0 e que MUX1 representa a parte comum
dos sinais V1 e V3. Por essa razão, os sinais de geração dos vetores foram redefinidos
para:
- V1: MUX1 · NFLGH;
- V2: MUX0;
- V3: MUX1 · (FLGH + FLGI1).
Com a utilização dos mesmos sinais para a geração dos vetores e seleção do valor final
calculado, a lógica combinacional do elemento de processamento foi bastante simplificada.
Terminado o projeto inicial do elemento de processamento, várias dessas unidades
foram descritas de forma a constituir o vetor sistólico do sistema. Cada uma dessas
unidades ocupou, em média, 30 elementos lógicos da FPGA.
No entanto, após testes iniciais para validar a solução, um novo problema tinha que
ser resolvido. O sistema em questão foge aos requisitos de entrada e saída discutidos no
capítulo 3.
65

As estruturas sistólicas são apropriadas para tarefas computacionalmente intensas mas
que possuem poucas operações de entrada e saída. A comunicação com o ambiente externo
ao sistema sistólico deveria ocorrer apenas nas células das bordas da estrutura.
O vetor sistólico proposto foge a essa regra pois cada célula deve se comunicar com a
memória externa para que o dado gerado em seu interior possa ser armazenado. Com o
crescimento desse vetor, cresce também a quantidade de células que precisam acessar a
memória externa.
Para uma seqüência de consulta com 1.000 bases, só a quantidade de pinos da FPGA
necessários para poder escrever os valores gerados na memória já inviabilizaria o processo,
fora sinais de endereço e controle. Além disso, a memória possui acesso seqüencial, não
aceitando escritas em paralelo.
Uma alternativa seria enfileirar os dados gerados, serializando a escrita na memória.
Porém, com essa abordagem, todo o ganho obtido com a computação paralela seria perdido.
Dessa forma, era necessário descobrir uma forma de compactar os valores calculados
ou uma maneira de diminuir sua quantidade.
4.4.2 Otimização de Utilização de Espaço e Armazenamento dos
Alinhamentos
O tamanho considerável que as seqüências biológicas podem ter impossibilita o armazenamento
da matriz de similaridades em memória. Hirschberg [29] propôs uma implementação
do algoritmo de Smith-Waterman utilizando espaço linear, aproveitando-se da
própria dependência de dados existente no cálculo da matriz de similaridades, uma vez
que somente os valores da linha anterior e da própria linha são necessários para o cálculo
de uma determinada linha da matriz.
No entanto, com essa otimização, os alinhamentos não podem ser recuperados pelo
procedimento normal de backtracking, pois a matriz não é armazenada em memória. Assim,
somente as coordenadas iniciais e finais de cada alinhamento são armazenadas. Dessa
maneira, a adoção de outras estratégias se fez necessário.
Estratégias Adotadas
Conforme já discutido, pelo enorme montante de dados gerados simultaneamente, era
inviável que esses dados fossem escritos diretamente na memória externa. Assim, estava
claro que seria necessário descrever alguma memória interna ao vetor sistólico para armazenar
temporariamente os valores calculados. Isso permitiria aplicar alguma heurística
que pudesse minimizar esse armazenamento e, posteriormente, entregar a matriz reduzida
para a memória externa.
A primeira particularidade observada na matriz de similaridade foi a grande quantidade
66

de elementos iguais a zero existentes. Devido a essa quantidade, podemos considerá-la uma
matriz esparsa e aplicar uma das técnicas de armazenamento vistas no capítulo 3 para
esse tipo de matriz.
Entretanto, nem todos os zeros da matriz podem ser descartados. Existem dois “tipos”
de zeros na matriz de similaridade: aqueles no qual os resultados parciais da equação de
recorrência foram todos negativos e a constante 0 foi escolhida como o valor máximo e
aqueles no qual um dos resultados parciais foi igual a zero e esse resultado tem prioridade
sobre a constante 0 da equação.
A figura 4.12 exemplifica esses dois tipos:
Figura 4.12: Tipos de zeros existentes na matriz de similaridade.
No tipo 1, a origem do valor zero calculado não foi nenhum dos três valores adjacentes
(diagonal, coluna à esquerda e linha superior). Já o zero do tipo 2 teve múltiplas origens.
Pela equação de recorrência, deve ser subtraído 1 do valor da diagonal caso as bases
comparadas sejam diferentes. Do valor da linha superior é sempre subtraído 2. Essas
duas operações resultam em zero e indicam a origem do novo valor calculado da matriz.
Assim, não existe nenhum vetor saindo de um zero do tipo 1, mas podem existir um
ou mais vetores saindo do zero do tipo 2. Esses zeros (tipo 2) não podem ser eliminados
pois eles podem fazer parte de uma seqüência considerada boa e que resultará em um
alinhamento a ser obtido.
A princípio, pode parecer não muito simples diferenciar um zero do tipo 1 de um zero
do tipo 2. Entretanto, os zeros do tipo 1 são os únicos elementos da matriz de similaridade
que não possuem vetores saindo deles. Como a célula de processamento descrita gera o
vetor indicando a origem do valor calculado, se o vetor produzido for nulo, ou seja, com
os três bits V1, V2 e V3 iguais a zero, significa que o dado gerado para aquela célula foi
um zero do tipo 1 e pode ser eliminado.
O início de qualquer seqüência dentro da matriz ocorre quando todos os valores adjacentes
(diagonal, linha superior e coluna à esquerda) ao valor a ser gerado são zeros do
tipo 1 e as duas bases comparadas são iguais. Assim, todas as seqüências têm como valor
inicial um 1 gerado a partir de um zero do tipo 1. Isso faz com que em um percorrimento
reverso de uma seqüência considerada boa, o último elemento seja sempre um zero do tipo
1. A função desse zero é servir como um marca para finalizar o percorrimento reverso.
Essa função que alguns zeros do tipo 1 podem ter poderia impedir que eles fossem
desprezados. Mas como toda seqüência possui o mesmo comportamento inicial, uma
67

marca (flag) colocada no dado gerado para a memória externa já implicaria que duas
bases iguais foram comparadas e que o valor 1 foi calculado a partir de um zero do tipo
1 dando início a uma nova seqüência. A estrutura do dado fornecido à memória externa
foi então modificada para que essa indicação fosse possível.
Esse resultado permitiu, além de descartar os zeros do tipo 1, armazenar o primeiro
dado de uma seqüência juntamente com o segundo valor dessa mesma seqüência. Como só
era necessário uma marca, o primeiro valor da seqüência não precisava mais ser guardado
explicitamente e poderia também ser desprezado.
Ainda mais, a aplicação da equação de recorrência na primeira coluna da matriz de
similaridade só resulta em zeros do tipo 1 e em valores iniciais de uma seqüência. Como
esses dois valores não precisam mais serem armazenados, conclui-se que todos os dados
da primeira coluna da matriz podem ser descartados.
A próxima observação feita é que os elementos iguais a zero da matriz (sejam eles
do tipo 1 ou 2) só podem ter setas diagonais apontando para eles. Para que essa seta
exista, ou seja, o zero faça parte de uma seqüência, as duas bases da diagonal seguinte
ao zero devem ser iguais. Esse fato não faz a menor diferença para zeros do tipo 1 pois
eles são eliminados de qualquer forma. Entretanto, isso permite que alguns zeros do tipo
2 também possam ser descartados.
Quando um zero desse tipo for gerado, faz-se uma “verificação antecipada” para saber
se esse zero fará parte de uma seqüência ou não. Isso é possível testando as duas bases que
serão utilizadas na geração do próximo valor da matriz de similaridade que se localiza na
diagonal seguinte a esse zero. Se elas forem iguais (situação 1), o zero fará parte de uma
seqüência e deve ser guardado. Se elas forem diferentes (situação 2), o zero calculado,
mesmo sendo do tipo 2, pode ser eliminado.
A figura 4.13 exemplifica o que foi dito acima.
Figura 4.13: Verificação antecipada para saber se o zero fará parte de uma seqüência.
Essa verificação antecipada é facilmente implementada. As duas bases que precisam
ser testadas para decidir se o zero calculado na célula corrente deve ser descartado ou
não estão presentes nas células vizinhas à esquerda e à direita. Como o elemento de
processamento em questão já se comunica com essas duas células, essas duas bases podem
ser fornecidas para a célula em questão e comparadas.
A figura 4.14 ilustra a posição das duas bases que precisam ser comparadas no instante
em que o zero é calculado.
68

Figura 4.14: Posição das bases para a verificação antecipada.
Com as otimizações feitas até aqui, um nova economia foi possível. No preenchimento
da matriz de similaridade, é muito comum que duas bases comparadas sejam iguais e
dêem início a uma nova seqüência. Na maioria dos casos, as bases comparadas da diagonal
seguinte são diferentes e, assim, a seqüência “morre” prematuramente. Essas seqüências
possuem o seguinte formato: 0 ← 1 ← 0, com o primeiro 0 sendo do tipo 1 e o segundo 0
sendo do tipo 2, mas sem nenhuma seta chegando nele.
Como o valor inicial da seqüência não é armazenado e o zero do tipo 2 sem setas
chegando nele é descartado, esse tipo de seqüência é automaticamente eliminado. Essa
situação pode ser observada na matriz de similaridade da figura 4.2, com as seqüências
citadas em uma tonalidade mais clara.
Finalmente, os valores gerados na última linha e na última coluna da matriz só precisam
ser guardados se forem maiores ou iguais ao valor considerado como ótimo para uma
seqüência. Como mais nenhum valor será calculado a partir desses dados, se uma seqüência
não atingiu o valor ótimo, ela não precisará ser recuperada.
Resumindo, as estratégias adotadas para reduzir a quantidade de dados armazenados
da matriz de similaridade foram:
- Zeros que não possuem setas saindo deles (tipo 1) podem ser descartados;
- Zeros que possuem setas saindo deles (tipo 2) só são armazenados se sua diagonal
seguinte possuir duas bases iguais;
- A seqüência 0 ← 1 ← 0 não é armazenada se o último zero obedecer a regra anterior;
- Não é necessário armazenar nenhum valor da primeira coluna da matriz de similaridade;
- A última coluna só armazena valores iguais ou maiores que o valor ótimo.
Vale ressaltar que a aplicação dessas regras não acarreta em nenhuma perda de informação,
ou seja, os alinhamentos que podiam ser obtidos antes de sua aplicação continuam
a ser recuperados após o uso dessas regras.
A utilização dessas simplificações na matriz de similaridade da figura 4.2 faz com que
apenas os elementos marcados com um círculo precisem ser armazenados. Essa matriz
possui 110 elementos e apenas 28 tiveram que ser guardados.
69

Vários exercícios feitos com matrizes que variaram de 4 × 4 (16 elementos) a 15 × 15
(225 elementos) mostraram que a redução obtida com essa heurística ficou entre 75 e
80%, ou seja, seria necessário armazenar apenas entre 20 e 25% dos valores gerados para
a matriz de similaridade.
Embora a redução tenha sido significativa, a quantidade de memória necessária ainda
é considerável. Para uma comparação de seqüências relativamente pequenas, em torno de
1.000 bases, a aplicação dessas regras reduziria a memória de 1MB para 200KB. Levandose
em conta que as seqüências podem atingir centenas de milhares de bases, essa redução
ainda não seria suficiente. Só para se ter uma idéia, uma comparação com seqüências de
400K bases necessitaria de uma memória inicial de 160GB e que poderia ser reduzida para
32 GB.
Para que todas essas otimizações pudessem ser implementadas, a estrutura do dado
gerado para a memória externa teve que ser bastante alterada. Três novos tipos de dados
foram definidos: um que indica o início de um alinhamento (final de um percorrimento
reverso) e contém duas bases alinhadas, um que indica um dado interno a um alinhamento
e um último que indica que o valor ótimo foi alcançado e um percorrimento reverso poderia
ser iniciado nesse ponto. A figura 4.15 ilustra o novo formato do dado a ser fornecido para
a memória externa.
Nessa nova estrutura, para simplificar a obtenção dos alinhamentos locais das duas
seqüências, a base da seqüência do banco de dados também foi incorporada ao dado
fornecido à memória externa. Com isso, os alinhamentos podem ser obtidos apenas com os
dados fornecidos, sem a necessidade de se ter em memória as duas seqüências comparadas.
Figura 4.15: Novo formato do dado fornecido à memória externa.
4.4.3 Outras otimizações
Além de todas as considerações feitas até aqui, no desenvolvimento do projeto foram
notadas algumas outras particularidades do sistema.
70

A célula inicial do vetor sistólico tem sempre os valores da diagonal e da coluna à
esquerda iguais a 0 e o valor da linha superior será no máximo igual a 1. Aplicando a
equação de recorrência com esses valores, percebe-se que o resultado parcial RES2 será
sempre negativo, ou seja, nunca será o escolhido como resultado final. Dessa forma, a
equação de recorrência só precisa ser aplicada ao elemento da diagonal. Como o valor da
diagonal é sempre zero, só existirão dois resultados finais possíveis para essa célula: 1 se
as duas bases comparadas forem iguais ou 0 caso contrário.
Por ter uma lógica combinacional bastante simplificada, a célula inicial do vetor
sistólico recebeu um tratamento diferenciado e foi descrita à parte.
Outra observação feita é que, com os valores utilizados na pontuação da equação de
recorrência, o valor máximo gerado pela célula inicial é igual a 1 (de acordo com o exposto
acima), igual a 2 para a segunda célula da estrutura, igual a 3 para a terceira, assim
sucessivamente, até a n-ésima célula da estrutura que terá um valor máximo calculado
igual a n.
Se todos os elementos de processamento fossem iguais, a sua lógica combinacional
interna teria que ser prevista para o pior caso. Supondo novamente um vetor com 1.000
células, o valor máximo gerado pela última célula seria igual a 1.000. Isso resultaria em
somadores, comparadores e multiplexadores de 10 bits (2 1 0 = 1.024). Essa quantidade
de bits para a segunda célula do vetor representaria um desperdício enorme já que ela
necessitaria de apenas 2 bits.
Dessa forma, o elemento de processamento foi descrito com um tamanho interno configurável.
A quantidade necessária de bits para cada célula é passada como um parâmetro
quando o elemento de processamento é instanciado na descrição em VHDL do vetor
sistólico.
71

Capítulo 5
RESULTADOS
Neste capítulo são apresentados os resultados obtidos a partir da implementação descrita
no capítulo 4. Como essa implementação se deu apenas em nível de síntese, os
resultados apresentados foram obtidos a partir de simulações feitas na ferramenta de desenvolvimento
do fabricante. Entretanto, essas ferramentas fornecem resultados bastante
precisos, não só em termos de funcionalidade do sistema, como também em termos de
velocidade final do sistema, indicando caminhos críticos e atrasos dos sinais. Além disso,
a comunicação com o ambiente externo não é crítica como em um sistema de tempo real,
o que poderia prejudicar os resultados da simulação.
Para a validação da arquitetura sistólica projetada não bastava apenas conhecer os
alinhamentos obtidos na comparação entre duas seqüências, mas também conhecer toda
a matriz de similaridade para verificar se as diversas otimizações sugeridas no capítulo 4
estavam sendo feitas corretamente. Assim, os testes foram todos feitos com seqüências
fictícias cuja matriz de similaridade era conhecida ou poderia ser construída facilmente.
Para o teste de desempenho, vetores de diferentes tamanhos foram sintetizados e suas
freqüências máximas de operação foram obtidas a partir de informações fornecidas pela
ferramenta de síntese.
5.1 Validação
Diversos arquivos de estímulo foram criados contendo seqüências de tamanhos variados.
Nas simulações feitas para a validação, limitou-se o tamanho das seqüências em 20 bases já
que o tamanho da matriz de similaridade se torna considerável para comprimentos acima
desse valor, dificultando bastante a análise e verificação.
Como primeiro exemplo, a comparação de duas seqüências pequenas, com apenas 5
bases cada, é apresentada. Nesse exemplo a base de consulta é CATAG e a base do banco
de dados ATAGC. Depois, é feita uma pequena modificação na seqüência da base de
dados, sendo alterada para CATGA. As matrizes de similaridade dessas duas seqüências
pode ser vista na figura 5.1.
Aplicando as otimizações em relação ao armazenamento da matriz vistas no capítulo 4,
72

Figura 5.1: Matrizes de similaridade para as seqüências CATAG e ATAGC e para CATAG e
CATGA.
apenas os valores circulados devem ser guardados. Note que, no primeiro caso, a matriz
possui 36 elementos mas somente 4 precisam ser salvos, ou seja, apenas 11
A simulação da primeira comparação pode ser vista na figura 5.2.
Figura 5.2: Comparação entre as seqüências CATAG e ATAGC.
A seqüência do banco de dados, que é a entrada principal da simulação, está delimitada
pelo sinal FLAG IN, lembrando que as bases foram codificadas internamente como A =
00, T = 01, C = 10 e G = 11. O valor ótimo fornecido ao sistema está armazenado em um
sinal interno VAL que, nesse caso, foi igual a 4. Os sinais MEM2, MEM3, MEM4 e MEM5
são os valores fornecidos para a memória externa pelas colunas 2, 3, 4 e 5, respectivamente
(a coluna inicial, do espaço, foi considerada como coluna 0). Conforme foi discutido no
capítulo 4, a primeira coluna (primeiro caracter da seqüência) não precisa fornecer dados
73

externamente.
Como saída do sistema, além dos dados para a memória externa, temos ainda os sinais
BASE OUT, DATA OUT, FLAG OUT (não colocado na figura) e CONTA. O sinal
BASE OUT é simplesmente a base do banco de dados após atravessar o vetor sistólico.
Já o sinal DATA OUT contém os valores calculados na última coluna da matriz de similaridade.
Note que os valores de DATA OUT estão associados com as bases do banco de
dados que estão na mesma linha. Dessa forma, para essa comparação (comparação 1 da
figura 5.1), temos a seguinte seqüência de saída nos sinais BASE OUT e DATA OUT: A0,
T0, A1, G4 e C2.
Esse formato de saída permite dividir uma seqüência de consulta que não caiba no
tamanho máximo do vetor em duas ou mais partes, ou seja, em dois ou mais vetores
sistólicos. A saída do primeiro vetor seria a entrada do segundo e assim, sucessivamente.
O último sinal, CONTA, é o valor de um contador interno e serve para que um programa
externo que esteja recebendo os dados gerados consiga remontar a matriz de similaridade.
Pela teoria de matrizes esparsas vista no capítulo 3, como a maior parte da
matriz original é desprezada, é necessário fornecer mecanismos para recuperar a posição
original na matriz completa de um valor armazenado na matriz reduzida. No nosso caso,
a coluna pode ser obtida pelo próprio elemento que gerou o dado externo, assim, um dado
lido de MEM2 é da segunda coluna e um dado lido de MEM5 pertence à quinta coluna.
Para a informação da linha, utiliza-se o sinal CONTA que indica o instante no qual o dado
foi gerado. No primeiro ciclo de relógio, só o valor da primeira coluna e primeira linha da
matriz é calculado. No segundo ciclo de relógio, são calculados o valor da primeira coluna
e da segunda linha e o valor da segunda coluna e primeira linha. No terceiro ciclo, os
valores da primeira coluna e terceira linha, segunda coluna e segunda linha e da terceira
coluna e primeira linha são gerados. Dessa forma, o valor lido do sinal CONTA menos a
coluna indica a linha do valor lido. Por exemplo, um dado lido de MEM2 com um valor
5 em CONTA indica que esse dado pertence à segunda coluna e terceira linha da matriz
original. Para a numeração de linha utilizada foi desconsiderada a linha inicial de zeros da
matriz, ou seja, a primeira linha é a primeira linha que contenha uma base da seqüência.
Analisando os dados gerados para a memória externa pela simulação, verifica-se que
MEM2 não forneceu nenhum valor, MEM3 forneceu apenas o valor 8AH, MEM4 forneceu
dois valores (22H e 39H) e MEM5 apenas 5AH. A quantidade de valores gerados para a
memória externa confere com os valores circulados na figura 5.1.
MEM3 forneceu o resultado 8AH quando o valor de CONTA era igual a 5, ou seja,
esse resultado pertence à terceira coluna e segunda linha da matriz original. Já MEM5
forneceu 5AH quando CONTA continha 9, ou seja, esse elemento está localizado na quinta
coluna e quarta linha da matriz original. Essas posições também conferem com o indicado
na figura 5.1.
Finalmente, em relação ao significado dos valores gerados, deve-se recorrer à estrutura
74

apresentada na figura 4.15. Com aquela estrutura, temos o seguinte resultado:
• MEM3: 8AH = 10001010B = 1 00 01 010 o percorrimento reverso deve ser feito
na diagonal e foi resultado da comparação de duas bases T, além disso, duas bases
A foram comparadas e são o final do percorrimento reverso (ou o início do alinhamento);
• MEM4: 22H = 00100010B = 0 0x 00 010 o percorrimento reverso deve ser feito na
diagonal e foi resultado da comparação de duas bases A;
• MEM4: 39H = 00111001B = 0 0x 11 001 o percorrimento reverso deve ser para a
linha superior e mesma coluna e a base G da seqüência do banco de dados deve ser
alinhada com um espaço;
• MEM5: 5AH = 01011010B = 0 1x 11 010 esse valor pode ser o ponto inicial de um
percorrimento reverso, que deve ser feito na diagonal e foi resultado da comparação
de duas bases G.
Novamente, os resultados estão coerentes com a matriz de similaridade obtida para
essa comparação.
A simulação da segunda comparação da figura 5.1, agora com um valor ótimo igual a
2, pode ser vista na figura 5.3.
Figura 5.3: Comparação entre as seqüências CATAG e CATGA.
Uma análise similar à que foi feita anteriormente mostra que os resultados gerados nesta
simulação estão corretos e são compatíveis com a matriz de similaridade da comparação
2 da figura 5.1.
75

Conforme previsto, apenas 7 valores são gerados para a memória externa (1 de MEM2,
2 de MEM3, 3 de MEM4 e 1 de MEM5). Como análise da informação fornecida por
esses dados, por exemplo, o valor 5AH fornecido por MEM5 indica um possível início
de percorrimento reverso (um valor maior ou igual ao valor ótimo), que o percorrimento
reverso deve ser feito na diagonal e que as duas bases comparadas foram G.
Como um último resultado de simulação, os valores gerados pela estrutura sistólica
para a matriz de similaridade obtida pela comparação das seqüências ACATAGGCAT e
CATAAGGCT (figura 4.2) são apresentados na figura 5.4. A seqüência CATAAGGCT
por ser menor, foi colocada dentro do vetor sistólico e a outra seqüência (considerada como
a seqüência proveniente do banco de dados) é que atravessou o vetor. Nessa simulação
é possível ver o sinal FLAG OUT e como ele acompanha as bases do banco de dados na
saída do vetor.
Em uma rápida inspeção, verifica-se que a seqüência de saída vinda de BASE OUT e
DATA OUT é igual à gerada na última coluna da matriz, ou seja, A0, C0, A0, T1, A0, G0,
G0, C3, A4 e T4. Já a quantidade de valores gerados para memória externa foi 28 (2 de
MEM2, 4 de MEM3, 5 de MEM4, 3 de MEM5, 4 de MEM6, 4 de MEM7, 4 de MEM8 e 2
de MEM9), o mesmo valor que resultaria na contagem dos valores circulados na figura 4.2.
Aparentemente MEM2 só gera um valor de saída, mas é que eles são iguais e o sinal que
indica um dado válido externo e permitiria essa diferenciação não foi mostrado.
Figura 5.4: Comparação entre as seqüências ACATAGGCAT e CATAAGGCT.
76

5.2 Desempenho
Para os testes de desempenho, vetores com diversos tamanhos foram sintetizados. Em
cada uma dessas sínteses, a ferramenta de desenvolvimento analisou os caminhos críticos e
os diversos atrasos (tempo que a mudança em sinal leva para gerar outros sinais estáveis)
e determinou a freqüência máxima de operação do circuito. Além disso, a quantidade de
elementos lógicos do FPGA utilizados por vetores de comprimentos diversos também foi
obtida (tabela 5.1).
Tabela 5.1: Quantidade de elementos lógicos utilizados e freqüência máxima de operação para
diferentes comprimentos do vetor sistólico.
Quantidade de Quantidade de Freqüência Média de elementos
células no vetor elementos lógicos máxima de utilizados por célula
do vetor
5 146 122,49 MHz 29,2
10 507 77,54 MHz 50,7
15 900 70,35 MHz 60
20 1292 64,94 MHz 64,6
25 1758 62,63 MHz 70,32
30 2222 56,45 MHz 74,06
40 3204 56,27 MHz 80,1
50 4403 56,1 MHz 88,06
Pode-se perceber que quanto maior a quantidade de células do vetor, menor sua
freqüência máxima de operação. Aparentemente, o aumento do número de células não
deveria afetar a freqüência de operação do circuito. As células possuem a mesma estrutura
interna e, assim, o atraso resultante da lógica combinacional contida em seu interior será
o mesmo. Esses atrasos de cada célula não são somados, pois as operações internas em
cada célula são executadas em paralelo dentro da estrutura. Dessa forma, o tempo que a
lógica combinacional precisaria para ter um sinal estável na saída indicaria a freqüência
máxima de operação do circuito. A adição de uma nova célula não alteraria esse tempo.
A explicação para tal fato é que com poucas células na estrutura, elas podem ser alocadas
em blocos contíguos no FPGA. Isso reduz bastante a necessidade de um roteamento
interno dos sinais, reduzindo os atrasos de comunicação entre as células. Com o aumento
do vetor sistólico, as células têm que ser espalhadas pelo FPGA e uma maior quantidade
de estruturas de roteamento precisam ser utilizadas, aumentando o tempo de comunicação
entre as células. Entretanto, esse atraso de comunicação também não é somado, e o maior
atraso de roteamento (caminho crítico), juntamente com a lógica combinacional da célula
é que irá definir a nova freqüência de operação do circuito. Assim, a partir de um determinado
ponto, a dispersão das células no FPGA já não irá afetar a freqüência de operação
pois o tempo de roteamento irá se estabilizar.
77

A figura 5.5 ilustra esse comportamento assintótico da freqüência máxima de operação.
Com poucas células, a freqüência de operação é fortemente afetada pelos atrasos de roteamento.
Com o aumento da estrutura e o espalhamento das células no FPGA, os atrasos de
roteamento passam a ser praticamente constantes (já se atingiu uma determinada distância
limite entre os blocos), praticamente não afetando mais a freqüência de operação. O valor
limite teórico obtido foi em torno de 56MHz.
Figura 5.5: Freqüência máxima de operação x Quantidade de células do vetor.
Em termos de quantidade de elementos lógicos do FPGA necessários para sintetizar
vetores de diferentes comprimentos, percebe-se uma relação linear entre essas quantidades
(figura 5.6), facilitando bastante estimativas de quantas células poderiam ser alocadas em
um determinado FPGA.
Por exemplo, para o FPGA da família APEX EP20K400EFC672 com 16.640 elementos
lógicos existente na placa PCI de testes, estima-se que possam ser alocadas 180 células de
um vetor sistólico em seu interior.
Comparação
O tempo de execução (comparação) do sistema projetado é dado pelo tempo que
a seqüência do banco de dados leva para atravessar a estrutura sistólica. Assim, se a
seqüência de consulta possuir n elementos e a seqüência do banco de dados possuir m
elementos, a seqüência do banco de dados atravessará o vetor em m + n ciclos de relógio.
78

Figura 5.6: Quantidade de elementos lógicos utilizados no FPGA x Quantidade de células do
vetor.
Dessa forma, podemos deduzir um fórmula que calcula o tempo de comparação entre duas
seqüências:
Texec = m + n
f clock
(5.1)
Apenas para se ter uma idéia do desempenho que essa implementação em hardware
poderia proporcionar, supondo que fosse possível criar um vetor sistólico sem limite de
comprimento, com uma freqüência de operação de 50 MHz, teríamos os seguintes tempos
(em segundos), comparados com uma implementação seqüencial e paralela desenvolvidas
em [47]:
79

Tabela 5.2: Comparação de velocidade entre uma implementação seqüencial, diversas paralelas
e em hardware do algoritmo baseado em programação dinâmica.
Tamanho das 2 4 8 Vetor
Seqüências Seqüencial Processadores Processadores Processadores Sistólico
15kB X 15kB 296s 283,18s 202,18s 181,29s 0,000614s
50kB X 50kB 3461s 2884,15s 1669,53s 1107,02s 0,002048s
80kB X 80kB 7967s 6094,19s 3370,40s 2162,82s 0,003277s
150kB X 150kB 24107s 19522,95s 10377,89s 5991,79s 0,006144s
400kB X 400kB 175295s 141840,98s 72770,99s 38206,84s 0,016384s
Embora o desempenho exibido na tabela 5.2 ainda não possa ser alcançado, por não ser
possível colocar essa quantidade de células em um FPGA considerando o atual estágio de
integração, ela demonstra o enorme ganho de velocidade que uma abordagem em hardware
pode proporcionar. Dessa forma, mesmo que as seqüências tenham que ser divididas em
pedaços menores, de forma que cada pedaço possa ser calculado dentro do FPGA, e depois
os resultados parciais reunidos de modo a produzir a solução completa, pela diferença de
velocidade apresentada, essa abordagem merece ser estudada.
80

Capítulo 6
CONCLUSÕES
O volume de informações geradas para os bancos de dados biológicos tem sido maior
que o crescimento do poder de processamento das máquinas utilizadas para processar essas
informações. Dessa forma, encontrar mecanismos eficientes para tratar esses dados é um
desafio constante da Bioinformática.
Dentre as operações necessárias para esse tratamento, uma das mais utilizadas é a
comparação de seqüências. O algoritmo de Smith-Waterman, baseado em programação
dinâmica, é o que produz os melhores resultados, mas apresenta complexidades quadráticas
de tempo e espaço, não sendo utilizado amplamente em projetos de seqüenciamento de
genomas. Os programas mais utilizados são baseados em probabilidades e heurísticas que,
apesar de serem consideravelmente mais rápidos, podem omitir resultados importantes.
Para tentar melhorar o desempenho dos algoritmos baseados em programação dinâmica,
soluções utilizando paralelismo vêm sendo desenvolvidas, tanto em hardware quanto em
software.
Este trabalho mostrou como um hardware dedicado, baseado em uma estrutura sistólica,
é capaz de linearizar a complexidade temporal e reduzir bastante o tempo de processamento
desses algoritmos.
Embora o dispositivo gerado tenha sido apenas em nível de síntese, os resultados
obtidos podem ser considerados bastante confiáveis, dada a precisão que a ferramenta de
síntese possui para simulações funcionais e temporais.
Para que a implementação proposta se torne funcional é necessário o desenvolvimento
de um programa que converta as seqüências para a codificação interna utilizada no vetor,
que forneça esses dados ao vetor pelo barramento PCI e que leia os dados gerados, montando
a matriz de similaridade completa ou trabalhando com a matriz reduzida para o
obtenção dos alinhamentos. Dada a velocidade na qual os resultados são produzidos pelo
vetor, o programa deverá possuir mecanismos de sincronização para não haver perda de
dados.
Esse mesmo programa poderia dividir as seqüências em vários pedaços menores e
efetuar a comparação desses pedaços menores, armazenando os resultados temporários e
depois montando uma solução final. Como a velocidade do hardware projetado é muito
81

grande, mesmo com uma granularidade pequena, que aumenta os custos de comunicação,
o desempenho final do sistema ainda deverá ser bastante satisfatório.
Outra possível implementação seria utilizar as soluções propostas em [50] e [47], baseadas
em [14]. Em cada um desses trabalhos foi desenvolvido um programa para paralelizar o
algoritmo de Smith-Waterman e, com isso, obter um ganho de performance. O problema
do cálculo da matriz de similaridade foi dividido em blocos e cada um desses blocos é
enviado para um processador do cluster. O hardware aqui proposto poderia ser utilizado
para o cálculo de cada um desses blocos menores. Uma placa PCI similar à utilizada nessa
dissertação poderia ser colocada em cada computador do cluster que, ao receber o bloco a
ser calculado, repassaria esse bloco para o vetor sistólico e armazenaria os valores gerados.
Dessa forma, teríamos dois níveis de paralelismo atuando, em software e em hardware, o
que poderia acelerar bastante o tempo de processamento dessas comparações.
Embora nesse trabalho tenha se conseguido simplificar bastante a quantidade de dados
que devem ser guardados da matriz de similaridade, o resultado obtido ainda está longe de
uma condição ideal. Pela revisão bibliográfica vista no capítulo 1, pode-se notar que o alvo
principal das pesquisas é proporcionar um ganho de velocidade ao algoritmo, com poucos
estudos sobre otimizações de espaço. Essa otimização é extremamente importante, dada
a enorme quantidade de elementos que a matriz de similaridade pode possuir. Já notando
esse problema, Cuvillo [14] sugere uma heurística para guardar apenas os alinhamentos
que poderiam ser considerados bons, ignorando os demais. A união das otimizações aqui
propostas com as utilizadas por Cuvillo poderiam ser avaliadas, bem como a aplicação de
outras técnicas que pudessem reduzir ainda mais a quantidade de dados armazenados.
Outro problema também não resolvido completamente foi o fornecimento dos valores
gerados pelo vetor para uma memória externa. Como vários valores podem ser gerados
simultaneamente, para que eles pudessem ser escritos em uma única memória, uma serialização
desses dados seria necessária. Isso acarretaria uma perda da performance obtida
nos cálculos em paralelo. Entre as possíveis soluções poderia se avaliar a utilização de
memórias entrelaçadas [35] e a divisão da memória em blocos. Além disso, a família
APEX de FPGAs da Altera, possui facilidades para implementar memórias de conteúdo
(CAM), que também poderiam ser avaliadas.
Finalmente, nas simplificações manuais feitas nos somadores e comparadores percebeuse
que a ferramenta de síntese gerou os mesmos resultados automaticamente. Entretanto,
na definição dos sinais internos para a geração dos vetores e escolha do melhor valor para a
célula, algumas simplificações manuais e algumas outras observações descritas no capítulo
4 resultaram em sínteses mais otimizadas que as obtidas automaticamente. Uma análise
mais aprofundada desses resultados fugia ao escopo desta pesquisa. Assim, poderia ser alvo
de estudo uma metodologia que forneça mecanismos ou aponte caminhos ao projetista para
que ele possa decidir que parte da descrição deve ser simplificada automaticamente e que
parte requer uma análise manual mais detalhada. A possível criação de uma biblioteca de
82

componentes ou unidades funcionais otimizadas que pudessem ser utilizadas em projetos
de maior porte também poderia fazer parte desse estudo.
83

REFERÊNCIAS BIBLIOGRÁFICAS
[1] IEE standard VHDL language reference manual, IEEE std. Relatório técnico, The
Institute of Electrical and Electronics Engineers, 1988.
[2] Primer on Molecular Genetics. U.S. DOE — Department of Energy., 1991.
[3] Initial sequencing and analysis of the human genome. Relatório técnico, The Genome
International Sequencing Consortium, Fevereiro de 2001.
[4] Adário, A. M. S., Bampi, S., e Jacobi, R. P. Reconfigurable architectures. volume 12,
páginas 133–136, Porto Alegre: PPGC da UFRGS, 1997.
[5] Adário, A. M. S., Roehe, E. L., e Bampi, S. Dynamically reconfigurable achitecture
for image processor applications. Em Design Automation Conference, páginas 623–
628. ACM, 1999.
[6] Altschul, S. F., Gish, W., Miller, W., Myers, E. W., e Lipman, D. J. Basic local
alignment search tool. Journal of Molecular Biology, 215:403–410, 1990.
[7] Amabis, J. M. e Martho, G. R. Curso Básico de Biologia, volume 1. Editora Moderna,
1988.
[8] Amabis, J. M. e Martho, G. R. Curso Básico de Biologia, volume 2. Editora Moderna,
1988.
[9] Arnold, J. M., Buell, D. A., e Davis, E. G. Splash 2. ACM Symposium on Parallel
Algorithms and Architectures, 1992, Junho.
[10] Aschenden, P. J. The Designer´s Guide to VHDL. Morgan Kaufmann Publishers,
Inc., San Francisco, CA, 1996.
[11] Brutlag, D. L., Dautricourt, J. P., Maulik, S., e Relph, J. Improved sensitivity of
searches of biological sequence databases. CABIOS, 6 (3):237–245, 1990.
[12] Carro, L. Projeto e Prototipação de Sistemas Digitais. Editora Universidade/UFRGS,
Porto Alegre, RS, 2001.
[13] Cormen, T. H., Leiserson, C. E., e Rivest, R. L. Introduction to Algorithms. MIT
Press: McGraw Hill, 1990.
[14] Cuvillo, J. Whole genome comparison using a multithreaded parallel implementation.
Dissertação de Mestrado, Universidade de Delaware, 2001.
[15] Dalton, J. Absorption of gases by water and other liquids. 1803.
[16] Dayhoff, M. O., Scwartz, R. M., e Orcutt, B. C. A model of evolucionary change
in proteins. volume 5, páginas 345–352, Washington, DC, 1978. Natl. Biomed. Res.
Foundation.
[17] Cuvillo, J. B.del , Martins, W. S., Gao, G. R., Cui, W., e Kim, S. ATGC: Another
tool for genome comparison. Relatório técnico.
84

[18] E., M. P. R. T. D. The Verilog Hardware Description Language. Kluwer Academics
Publishers, 1991.
[19] Eijikhout,. Lapack working note 50: Distributed sparse data structures for linear
algebra operations. Relatório técnico, Computer Science Department, University of
Tennessee, Knoxville, TN, 1992.
[20] Gajski, D., Dutt, N., Wu, A., e Lin, S. Sigh Level Systems – Introduction to Chip and
System Design. Kluwer Academic Publishers, Massachusets, Estados Unidos, 1992.
[21] Gibas, C. e Jambeck, P. Developing Bioinformatics Computer Skills. O’Reilly, 2001.
[22] Gokhale, M. Splash: A reconfigurable linear logic array. Procedings of 1990 International
Conference on Parallel Processing, páginas 526–532, 1990.
[23] Gotoh,. An improved algorithm for matching biological sequences. J. Mol. Biol.,
162:705–708, 1982.
[24] Grice, J. A., Hughey, R., e Speck, D. Parallel sequence alignment in limited space.
Em Proc. Int. Conf. Intelligent Systems for Molecular, páginas 145–153. AAAI/MIT
Press, 16-19 de Julho de 1995.
[25] Guccione, S. A. e Keller, E. Gene matching using jbits. Xilinx, Inc., 2002.
[26] Hadley, J. D. e Hutchings, B. L. Design methodologies for partially reconfigured
systems. páginas 78–84, Califórnia, Estados Unidos, 1995.
[27] Henikoff, S. e Henikoff, J. G. Aminoacid substitution matrices from proteins blocks.
volume 89, páginas 10915–19, 1992.
[28] Hill, F. J. e Peterson, G. R. Computer Aided Logical Design with Emphasis on VLSI.
John Wiley & Sons, Inc, 4 edição, 1993.
[29] Hirschberg, D. A linear space algorithm for computing maximal common subsequences.
Communications of the ACM, 18:341–343, 1975.
[30] Hirschberg, J. D., Hughey, R., e Karplus, K. Krestel: A programmable array for
sequence analysis. Em Proc. Int. Conf. Application-Specific Systems, Architectures
and Processors, páginas 25–34. IEEE CS, 19-21 de Agosto de 1996.
[31] Hoang, D. T. A systolic array for the sequence alignment problem. Relatório Técnico
CS-92-22, Brown University, Providence, RI, 1992.
[32] Hoang, D. T. e Lopresti, D. P. FPGA implementation of systolic sequence alignment.
1992.
[33] Hughes, N. Implementing sequence matching algorithms with hardware compilation.
Relatório técnico, St. Hugh’s College.
[34] Hughey, R. Parallel hardware for sequence comparison and alignment. CABIOS,
12(6):473–479, Dezembro de 1996.
[35] Hwang, K. Advanced Computer Architecture. McGraw-Hill International Editions,
Nova Iorque, 1993.
[36] Information Sciences Institute - East, http:// www.east.isi.edu/projects/SLAAC/.
Slaac project. World Wide Web site.
[37] Kung, H. T. Why systolic architectures? IEEE Computer, 15 (1):37–46, Janeiro de
1982.
[38] Lavenier, D. Dedicated hardware for biological sequence comparison. 1996.
85

[39] Lavenier, D. SAMBA - Systolic Accelerators for Molecular Biological Applications.
Relatório Técnico 988, IRISA, Março de 1996.
[40] Lavenier, D. Speeding up genome computations with a systolic accelerator. SIAM
News, 31(8):1–7, Outubro de 1998.
[41] Lewin, B. Genes VII. Artmed, Porto Alegre, RS, Brasil, 2001.
[42] Lipsett, R., Schaefer, C., e Ussery, C. VHDL: Hardware Description and Design.
Kluwer Academic Press, 1989.
[43] Lipton, R. J. e Lopresti, D. A systolic array for rapid string comparison. Em Chapel
Hill Conference on VLSI, páginas 363–376, 1985.
[44] Luscombe, N. M., Greenbaum, D., e Gerstein, M. Yearbook Of Medical Informatics
2001, chapter What is bioinformatics? An introduction and overview, páginas 83–
100. International Medical Informatics Association, 2001.
[45] Martins, W. S., Cuvillo, J. B.del , Useche, F. J., Theobald, K. B., e Gao, G. R.
A multithreaded parallel implementation of a dynamic programming algorith for
sequence comparison. Relatório técnico.
[46] Martins, W. S., Cuvillo, J.del , Cui, W., e Gao, G. R. Whole genome alignment using
a multithreaded parallel implementation. Relatório técnico.
[47] Melo, R. C. F. Comparação de seqüências biológicas utilizando dsm. Dissertação
de Mestrado, Departamento de Ciência da Computação, Universidade de Brasília,
Brasília, DF, Janeiro de 2003.
[48] Michel, P., Lauther, U., e Duzy, P. The Synthesis Approach to Digital Systems Design.
Kluwer Academic Publishers, Massachusets, Estados Unidos, 1992.
[49] Michele, G. D. Synthesis and Optimization of Digital Circuits. McGraw-Hill, 1994.
[50] Murakami, M. M. Uma nova abordagem para pesquisa paralela em bancos de dados
biológicos utilizando algoritmos de comparação de seqüências baseados em programação
dinâmica. Dissertação de Mestrado, Departamento de Ciência da Computação,
Universidade de Brasília, Brasília, DF, Março de 2003.
[51] Needleman, S. B. e Wunsch, C. D. A general method applicable to the search for
similarities in the amino acid sequence of two proteins. volume 48, páginas 443–453,
1970.
[52] Splash 2, S. G. D.on . Dzung t. hoang. páginas 185–191, Los Alamitos, CA, 1993.
IEEE Computer Society Press.
[53] ONSA - Organization for Nucleotide Sequencing and Analysis,
http://watson.fapesp.br/onsa/Genoma3.htm. Genoma3.
[54] Page, I. Reconfigurable processor architectures. Microprocessors and Microsystems
(Special Issue on Codesign), 20:185–196, 1996.
[55] Pappas, N. P. Searching biological sequence databases using distributed adaptive
computing. Dissertação de Mestrado, Virginia Polytechnic Institute and State University,
Blacksburg, Virginia, Janeiro de 2003.
[56] Paracel, Inc, http://www.paracel.com/. 2001.
[57] Paracel Inc, http://www.paracel.com/products/pdfs/gm2 datasheet.pdf. The Genematcher2
System Datasheet, 2002.
[58] Patzer, A. Highly parallel DNA sequence matching and alignment processor.
86

[59] Pearson, W. R. e Lipman, D. L. Improved tools for biological sequence comparison.
Proceedings Of The National Academy Of Science USA, 85:2444–2448, Abril de 1988.
[60] Puttegowda, K., Worek, W., Pappas, N., Dandapani, A., e Athanas, P. A run-time
reconfigurable system for gene-sequence searching. Proceedings of the International
VLSI Design Conference, Janeiro de 2003.
[61] Rognes, T. ParAlign: a parallel sequence alignment algorithm for rapid and sensitive
database searches. Nucleic Acids Research, 29(7):1647–1652, 2001.
[62] Rognes, T. e Seeberg, E. Six-fold speed-up of Smith-Waterman sequence database
searches using parallel processing on common microprocessors. Bioinformatics,
16(8):699–706, 2000.
[63] Saad,. Sparskit: A basic tool kit for sparse matrix computation. Relatório Técnico
CSRD TR 1029, University of Illinois, Urbana, IL, 1990.
[64] Setubal, J. C. e Meidanis, J. Computational Molecular Biology. PWS, 1997.
[65] Simpson, A. J. G. The genome sequence of the plant pathogen xylella. Nature,
406:151–157, Julho de 2000.
[66] Smith, T. e Waterman, M. Identification of common molecular subsequences. Journal
of Molecular Biology, 147:195–197, 1981.
[67] TimeLogic Corp, http://www.timelogic.com. 2002.
[68] TimeLogic Corp, http://www.timelogic.com/ decypher intro.html. DeCypher, 2002.
[69] Trelles, O. On the parallelization of bioinformatic applications. volume 2, 2001.
[70] Villasenor, J. e Amgione-Smith, W. Configurable computing. Scientific American,
19:54–58, 1997.
[71] Waterman, M. S. Sequence alignments. páginas 53–92. CRC Press, 1989.
[72] Watson, J. D. e Crick, F. H. Molecular structure of nucleic acids: A structure for
deoxyribose nucleic acid. Nature, 171:737–738, Abril de 1953.
[73] White, C. T., Singh, R. K., Reintjes, P. B., Lampe, J., Erickson, B. W., Dettloff,
W. D., Chi, V. L., e Altschul, S. F. Bioscan: A vlsi system based for biosequence
analysis. páginas 504–509. IEEE Computer Society Press, 1991.
[74] Worek, W. J. Matching genetic sequences in distributed adaptive computing systems.
Dissertação de Mestrado, Virginia Polytechnic Institute and State University,
Blacksburg, Virginia, Julho de 2002.
[75] Xilinx, Inc., http://www.xilinx.com.
[76] Yamaguchi, Y., Maruyama, T., e Konagaya, A. High speed homology search with
FPGAs. Pacific Symposion on Biocomputing, páginas 271–282, 2002.
[77] Yang, B. H. W. A parallel implementation of Smith-Waterman sequence comparison
algorithm. Relatório Técnico ID: 4469409, Instituição, 2002.
[78] Yu, C. W., Kwong, K. H., Lee, K. H., e Leong, P. H. W. A smith-waterman systolic
cell. The Chinese University of Hong Kong, 2003.
87