Apresentação e Análise dos Resultados da Experimentação

Antes de iniciar a análise dos conjuntos de testes dos dois experimentos previstos é

importante que se faça uma análise da estimativa do comportamento de requerimentos

de memória dos algoritmos. Essas estimativas foram confeccionadas com base na

memória necessária para acomodar as principais estruturas de dados dos algoritmos, que

são a matriz de PD, no caso do algoritmo básico, e o arrays para armazenar os

checkpoints, no caso dos demais algoritmos. Foram considerados tamanhos de

seqüências variando de 2.000 a 2.048.000 resíduos com incrementos segundo uma

distribuição geométrica de razão 2. É importante salientar que essas estimativas, além

de desprezar as outras estruturas de dados alocadas pelo aplicativo (algoritmo), não

considera a memória ocupada pelo Sistema Operacional e pelo ambiente gráfico KDE,

mas essas têm o mesmo impacto em todos os aplicativos (algoritmos).

As Tabelas 5.3 e 5.4 sintetizam os dados destas estimativas, sendo que na Tabela 5.3

estão relatados os dados brutos, com valores absolutos expressos em Mega bytes (Mb).

A Tabela 5.4 contém as estimativas da Tabela 5.3 normalizados pelos valores do

algoritmo básico. O algoritmo básico foi tomado como referência da normalização,

ficando, portanto, com um valor de 1 unidade.

O Sistema Operacional precisou alocar pelo menos 1.099 Mb para o algoritmo de

Viterbi básico alinhar seqüências de 32.000 resíduos, relativas à memória para

armazenagem das principais estruturas de dados, entretanto não foi possível alocar

2.197 Mb para o alinhamento de seqüências com 64.000 resíduos. O mesmo aconteceu

com o algoritmo de Viterbi com 2-níveis de checkpoints por diagonais, que só

conseguiu memória suficiente para alinhar seqüencias de até 64.000 resíduos, mas não

conseguiu alocar 1.584 Mb – memória para as principais estruturas de dados – para

alinhar seqüências com 128.000 resíduos.

Os demais algoritmos de Viterbi foram testados contra seqüências de até 512.000

resíduos, mas observando os dados da Tabela 5.3, sabendo-se que foi possível alocar

1.099 Mb para o algoritmo de Viterbi básico e supondo tamanhos crescentes de

seqüências conforme uma progressão geométrica com razão 2, espera-se que seja

possível alinhar seqüências com 1.024.000 resíduos com o algoritmo de Viterbi com

2-níveis de checkpoints por linhas, que necessita de pelo menos 1.107 Mb, e com o

algoritmo de Viterbi proposto 2, necessita de pelo menos 808 Mb.

Observando-se os dados da Tabela 5.4 pode-se verificar o comportamento assintótico, a

posteriori, dos requisitos de memória dos algoritmos considerados nos experimentos,

quando comparados com o algoritmo de Viterbi básico. O algoritmo de Viterbi com

2-níveis de checkpoints por linhas requer 3,2% de memória para todos os tamanhos de

seqüências. Os algoritmos de Viterbi propostos 1 e 2 apresentam queda nos requisitos de

memória para tamanhos crescentes de seqüências, sendo que o proposto 1 decresce de

8,8% (2.000 resíduos) para 4,5% (2.048.000 resíduos) e o proposto 2 decresce de 4,4%

(2.000 resíduos) para 2,3% (2.048.000 resíduos). Já o algoritmo de Viterbi com 2-níveis

de checkpoints por diagonais apresenta comportamento crescente dos requisitos de

memória para tamanhos crescentes de seqüências, ele cresce de 6,3% (2.000 resíduos)

para 143,2% (2.048.000 resíduos).

O que se deve observar nesses algoritmos com requisitos de memória reduzido é

justamente o comportameno assintótico dos requisitos de memória destes quando o

tamanho das seqüências cresce, pois eles são úteis justamente para o alinhamento de

seqüências cujos comprimentos estão além daqueles que o algoritmo de Viterbi básico

pode tratar. Nesse sentido, o algoritmo de Viterbi com 2-níveis de checkpoints por

diagonais, que apresenta um comportamento crescente dos requisitos de memória,

chegando mesmo a ultrapassar os requisitos do algoritmo de Viterbi básico, é o que

apresentou o pior comportamento assintótico, indicando que os requisitos de memória

crescem para o infinito mais rapidamente que o algoritmo de Viterbi básico, quando o

tamanho das seqüências tendem ao infinito.

TABELA 5.3 – Resultados das Estimativas dos Requerimentos de Memória para os

Algoritmos de Viterbi (Valores em Mb).

Viterbicom 2-níveis de checkpoints (por)

Comp.

Seqüências

Viterbi

Básico Linhas Diagonais Proposto 1 Proposto 2

2.000 69 2 4 6 3

4.000 137 4 11 10 5

8.000 275 9 27 18 9

16.000 549 17 74 33 16

32.000 1.099 35 202 61 30

64.000 2.197 69 564 114 57

128.000 4.395 138 1.584 218 109

256.000 8.789 277 4.460 421 211

512.000 17.578 554 12.595 823 411

1.024.000 35.156 1.107 35.596 1.616 808

2.048.000 70.313 2.215 100.652 3.192 1.596

O algoritmo de Viterbi com 2-níveis de checkpoints por linhas apresentou um

comportamento assintótico constante dos requisitos de memória, relativamente ao

algoritmo de Viterbi básico. Os algoritmos de Viterbi com 2-níveis de checkpoints

propostos, 1 e 2, apresentaram comportamento assintótico decrescente dos requisitos de

memória, relativamente ao algoritmo de Viterbi básico. Mostrando-se, desta forma,

serem mais úteis do que os demais algoritmos considerados nesses experimentos,

quando a economia de espaço é a variável de performance mais importante a ser

considerada.

TABELA 5.4 – Resultados das Estimativas Normalizadas dos Requerimentos de

Memória para os Algoritmos de Viterbi (Básico = 1).

Viterbicom 2-níveis de checkpoints (por)

Comp.

Seqüências

Viterbi

Básico Linhas Diagonais Proposto 1 Proposto 2

2.000 1,000 0,032 0,063 0,088 0,044

4.000 1,000 0,032 0,077 0,076 0,038

8.000 1,000 0,032 0,100 0,066 0,033

16.000 1,000 0,032 0,134 0,060 0,030

32.000 1,000 0,032 0,184 0,055 0,028

64.000 1,000 0,032 0,257 0,052 0,026

128.000 1,000 0,032 0,361 0,050 0,025

256.000 1,000 0,032 0,508 0,048 0,024

512.000 1,000 0,032 0,717 0,047 0,023

1.024.000 1,000 0,032 1,013 0,046 0,023

2.048.000 1,000 0,032 1,432 0,045 0,023

Após a codificação, otimização e compilação dos algoritmos, foram efetuados os

conjuntos de testes previstos nos dois experimentos. O conjunto de testes previsto no

primeiro experimento foi preparado para verificar o comportamento dos algoritmos até

que os recursos de memória do PC fossem exauridos por algum dos algoritmos, ou seja,

até o início de paginação excessiva. O conjunto de testes previsto no segundo

experimento foi preparado para verificar o comportamento dos algoritmos, pelo menos,

até que os recursos de memória do PC fossem exauridos por algum dos algoritmos de

interesse primário nessa investigação, por um dos algoritmos propostos ou pelo

algoritmo de Viterbi com 2-níveis de checkpoints por diagonais, com retrocedimento

restrito e particionamento móvel de memória. Entretanto, o conjunto de testes previsto

no segundo experimento foi ampliado para verificar, também, o comportamento do

algoritmo de Viterbi com 2-níveis de checkpoints por linhas até o ponto em que esse

exaurisse os recursos de memória do PC. O conjunto de testes previsto no terceiro

experimento foi preparado para verificar o comportamento dos algoritmos no

alinhamento de seqüências relativamente pequenas, por exemplo as seqüências de

proteínas que possuem comprimento médio de 368 resíduos.

Nos três conjuntos de testes realizados, foram calculados os tempos de CPU e os tempos

totais de execução (wall time), para todos os algoritmos. Nesses testes foram tomadas as

médias aritméticas de 5 re-estimações do tempo de CPU e de 5 re-estimações do tempo

total de execução (Wall Time) para cada seqüência de aminoácidos (proteínas). Os

resultados do primeiro e do segundo conjunto de testes, os tempos de CPU e os tempos

totais de execução (Wall time), estão sintetizados nas Tabelas 5.5 e 5.6,

respectivamente. Esses tempos foram medidos tomando-se um segundo como a unidade

básica de medida do tempo e estão registrados nas tabelas como valores absolutos em

segundos.

TABELA 5.5 – Resultados dos Tempos de CPU e dos Tempos Totais de Execução

(Wall Time) do Primeiro Experimento para os Algoritmos de Viterbi

(Tempos em Segundos).

Viterbicom 2-níveis de checkpoints (por)

Viterbi Básico

linhas diagonais proposto 1 proposto 2

Comp.

seqüên.

CPU Wall CPU Wall CPU Wall CPU Wall CPU Wall

2.000 1,248 1,304 2,326 2,338 2,154 2,480 1,016 1,066 1,024 1,025 4.000 _{2,552 2,580 4,798 4,826 5,124 5,155 2,158 2,175 2,176 2,315} 6.000 3,896 3,993 7,330 7,385 8,232 8,280 3,342 3,369 3,292 3,305 8.000 6,254 6,292 11,946 12,044 11,148 11,224 5,926 5,953 5,902 5,923 10.000 7,862 7,916 14,968 15,065 14,260 14,368 7,448 7,501 7,394 7,428 12.000 22,498 76,456 16,034 18,148 17,280 17,389 9,150 9,204 8,938 8,974 14.000 22,048 113,206 21,078 21,210 20,436 20,564 10,498 10,560 10,498 10,538 16.000 28,270 126,858 24,092 24,241 23,506 23,656 12,012 12,080 11,962 12,015 18.000 33,548 144,600 27,078 27,243 26,474 26,626 13,492 13,569 13,406 13,461 20.000 33,042 169,249 30,104 30,292 29,096 29,282 15,022 15,121 14,902 14,975 22.000 38,735 189,375 33,156 33,366 32,286 32,474 16,560 16,668 16,404 16,478 24.000 44,480 197,929 36,258 36,440 35,588 35,844 18,026 18,141 17,902 17,979 26.000 48,318 208,825 39,362 39,639 38,596 38,820 19,556 19,681 19,496 19,580 28.000 48,292 211,159 42,286 42,662 41,898 42,177 21,076 21,202 21,088 21,186 30.000 59,052 223,569 45,314 45,621 44,760 45,069 22,622 22,762 22,506 22,602 32.000 67,618 224,634 48,306 48,613 48,148 48,454 24,070 24,227 23,928 24,043

165

Essas medidas – os resultados – do desempenho dos algoritmos foram, também,

apresentados em dois conjuntos de gráficos, para permitir um melhor entendimento

através da visualização do comportamento destes. Foram elaborados quatro gráficos de

linhas para os dados das Tabelas 5.5 e 5.6, sendo dois para cada uma das tabelas. Os

gráficos das Figuras 5.3 e 5.4 foram confeccionados com os dados da Tabela 5.5,

representando os tempos de CPU e os tempos totais de execução, respectivamente,

enquanto que os gráficos das Figuras 5.5 e 5.6 foram confeccionados com os dados da

Tabela 5.6, representando os tempos de CPU e os tempos totais de execução,

respectivamente.

Os gráficos das Figuras 5.3 e 5.4 foram confeccionados com base nos dados

normalizados em relação aos dados do algoritmo de Viterbi básico (básico = 1). Os

gráficos das Figuras 5.5 e 5.6 foram confeccionados adotando-se a escala logarítmica

em ambos os eixos de coordenadas cartesianas, pois a amplitude dos dados é muito

grande para assumir uma escala linear e ainda assim ressaltar o comportamento da

performance dos algoritmos usados nos experimentos.

Das Tabelas 5.5 e 5.6, e das Figuras 5.3 a 5.6, pode ser verificado que: o algoritmo de

Viterbi básico provocou atividade de paginação significativa para o alinhamento de

seqüências de tamanhos maiores ou iguais a 12.000 resíduos e provocou o início de

atividade excessiva de paginação para seqüências compostas por 32.000 resíduos; o

algoritmo de Viterbi com 2-níveis de checkpoints por diagonais provocou o início da

atividade significativa de paginação para o alinhamento de seqüências de tamanhos

compreendidos entre 32.000 e 64.000 resíduos e provocou atividade excessiva de

paginação para seqüências compostas por 64.000 resíduos; o algoritmo de Viterbi com

2-níveis de checkpoints por linhas provocou o início da atividade significativa de

paginação para o alinhamento de seqüências de tamanhos compreendidos entre 256.000

e 512.000 resíduos e provocou atividade excessiva de paginação para seqüências

compostas por 512.000 resíduos.

Por outro lado, pode-se observar que os algoritmos de Viterbi propostos 1 e 2 somente

apresentaram pequenos aumentos nos tempos totais de execução para seqüências

compostas por 512.000 resíduos, quando comparados com os respectivos tempos de

CPU. O algoritmo de Viterbi proposto 1 apresentou um aumento de aproximadamente

30%, o que talvez possa indicar proximidade do início de atividade significativa de

paginação. Já, o algoritmo de Viterbi proposto 2 apresentou um aumento de

aproximadamente 10%, o que ainda não chega a ser uma sinalização do início de

atividade significativa de paginação. Assim, o algoritmo de Viterbi proposto 1 ainda

pode alinhar seqüências bem maiores do que 512.000 resíduos (no PC usado para os

testes deste trabalho) e, o algoritmo de Viterbi proposto 2 ainda pode alinhar seqüências

maiores do que 1.024.000 resíduos no PC usado para os testes deste trabalho,

requerendo alocação de pelo menos 808 Mb de memória (Tabela 5.3).

TABELA 5.6 – Resultados dos Tempos de CPU e dos Tempos Totais de Execução

(Wall Time) do Segundo Experimento para os Algoritmos de Viterbi

(Tempos Em Segundos).

Viterbicom 2-níveis de checkpoints (por)

Viterbi

Básico linhas diagonais proposto 1 proposto 2

Comp.

seqüên.

CPU Wall CPU Wall CPU Wall CPU Wall CPU Wall

2.000 1,248 1,304 2,326 2,338 2,154 2,480 1,016 1,066 1,024 1,025 4.000 2,552 2,580 4,798 4,826 5,124 5,155 2,158 2,175 2,176 2,315 8.000 6,254 6,292 11,946 12,044 11,148 11,224 5,926 5,953 5,902 5,923 16.000 28,270 126,858 24,092 24,241 23,506 23,656 12,012 12,080 11,962 12,015 32.000 67,618 224,634 48,306 48,613 48,148 48,454 24,070 24,227 23,928 24,043 64.000 - - 97,962 98,373 104,618 640,054 48,676 48,876 48,240 48,469 128.000 - - 196,884 197,777 - - 97,500 97,938 96,980 97,427 256.000 - - 393,384 396,260 - - 206,320 253,470 193,026 194,222 512.000 - - 1924,024 6729,183 - - 436,422 559,476 423,274 468,180

Os algoritmos propostos 1 e 2 tiveram desempenhos semelhantes em relação aos tempos

de CPU e tempos totais de execução no alinhamento de seqüências no intervalo de

2.000 a 32.000 resíduos a um HMM com 2.000 nós, veja a Tabela 5.5 e as Figuras 5.3 e

5.4. Com relação aos tempos de CPU o algoritmo proposto 2 foi, na maioria das vezes,

mais rápido do que o 1, chegando a uma diferença máxima de 2.5% (6.000 resíduos),

sendo mais lento, somente, para as seqüências com 4.000 (0,8%) e 28.000 (0.06%)

resíduos. Com relação aos tempos totais de execução o algoritmo proposto 2 foi mais

lento do que o 1 apenas para seqüências de 4.000 resíduos (6%) e, foi no máximo 2.5%

mais rápido (12.000 resíduos) para as demais seqüências.

Observando-se a Tabela 5.5 e as Figuras 5.3 e 5.4, pode-se notar que os algoritmos

propostos 1 e 2 sempre apresentaram desempenho superior aos demais para as medidas

de tempos no alinhamento de seqüências no intervalo de 2.000 a 32.000 a um HMM

com 2.000 nós, sendo no mínimo 5,2% (8.000 e 10.000 resíduos) mais rápido que o

algoritmo de Viterbi básico para as seqüências no intervalo considerado. Os algoritmos

de Viterbi propostos 1 e 2 foram com relação aos tempos de CPU, pelo menos 2,1 (em

14.000 resíduos) vezes mais rápidos, e com relação aos tempos totais de execução cerca

de 8 a 10 vezes mais rápidos do que o algoritmo de Viterbi básico para seqüências

maiores ou iguais a 12.000 resíduos – início da degradação do uso de memória pelo

algoritmo de Viterbi básico.

0,00 0,50 1,00 1,50 2,00 2,50 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32

Tamanhos das seqüência (x 1000 radicais)

Tempos de CPU normalizados (básico = 1

)

Viterbi Básico

2-níveis Checkpoints Linha

2-níveis Checkpoints Bidimensional 1 2-níveis Checkpoints Bidimensional 2 2-níveis Checkpoints Diagonais

FIGURA 5.3 – Tempos de CPU dos algoritmos Viterbi para alinhamento de seqüências

de aminoácidos a um HMM com 2000 nós.

O algoritmo de Viterbi com 2-níveis de checkpoints por linhas e o por diagonais

desempenharam de forma semelhante no intervalo de 2.000 a 32.000, veja a Tabela 5.5

e as Figuras 5.3 e 5.4, com discrepâncias significativas no intervalo de 2.000 a 10.000

resíduos, mas com desempenho praticamente semelhante para seqüências no intervalo

de 12.000 a 32.000 resíduos.

0,00 0,50 1,00 1,50 2,00 2,50 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32

Tamanhos das Seqüência (x 1000 radicais)

Tempos totais de execução normalizados (básico = 1

) Viterbi Básico

2-níveis Checkpoints Linha

2-níveis Checkpoints Bidimensional 1 2-níveis Checkpoints Bidimensional 2 2-níveis Checkpoints Diagonais

FIGURA 5.4 – Tempos totais de execução dos algoritmos de Viterbi para alinhamentos

de seqüências de aminoácidos a um HMM com 2000 nós.

Da Tabela 5.5 e da Figura 5.3 pode-se notar que o algoritmo de Viterbi com 2-níveis de

checkpoints por linhas e o por diagonais sempre apresentaou desempenho inferior aos

algoritmos propostos 1 e 2 para as medidas de tempos no alinhamento de seqüências no

intervalo de 2.000 a 32.000 resíduos a um HMM com 2.000 nós. Os algoritmos de

Viterbi propostos 1 e 2 foram, respectivamente, cerca de 1,7 a 2,5 vezes mais rápidos,

em tempos de CPU, do que o algoritmo de Viterbi com 2-níveis de checkpoints por

linhas e do que o algoritmo por diagonais. Essas comparações são muito semelhantes

para os tempos totais de execução, veja a Figura 5.4, com os algoritmos propostos 1 e 2

sendo cerca de 1,9 a 2,5 vezes mais rápidos que o algoritmo de Viterbi com 2-níveis de

checkpoints por linhas e do que o algoritmo por diagonais.

O algoritmo de Viterbi com 2-níveis de checkpoints por linhas e o por diagonais

apresentaram desempenho inferior ao algoritmo de Viterbi básico para as medidas de

tempos no intervalo de 2.000 a 10.000 resíduos, com queda de desempenho por um

fator de ~1,8, veja a Tabela 5.5 e as Figuras 5.3 e 5.4. Por outro lado para seqüências no

intervalo de 14.000 a 32.000 resíduos eles apresentaram um desempenho superior ao

algoritmo de Viterbi básico para as medidas de tempos, com um ganho de desempenho

de até ~1,4 para os tempos de CPU e de até ~5,0 para os tempos totais de execução.

1 10 100 1000 10000 2 4 8 _{16 32 64} 12⁸ 25⁶ 51²

Tamanhos das seqüências (x 1000 radicais)

Te mpos de CPU (s egundos ) Viterbi Básico

2-níveis Checkpoints Linha

2-níveis Checkpoints Bidimensional 1 2-níveis Checkpoints Bidimensional 2 2-níveis Checkpoints Diagonal

FIGURA 5.5 – Tempos de CPU dos algoritmos de Viterbi para alinhamentos de

seqüências de aminoácidos a um HMM com 2000 nós (eixos

logarítmicos).

Os dados sintetizados na Tabela 5.6 e nas Figuras 5.5 e 5.6, apresentam resultados

relativos aos tempos de CPU e tempos totais de execução semelhantes aos da Tabela 5.5

e das Figuras 5.3 e 5.4, exceto para os pontos em que o algoritmo de Viterbi com

níveis de checkpoints por diagonais e o algoritmo por linhas exauriram os recursos de

memória do PC. O algoritmo de Viterbi com 2-níveis de checkpoints por diagonais

provocou atividade excessiva de paginação para seqüências de 64.000 resíduos e não

conseguiu alocar recursos de memória para alinhar seqüências com 128.000 resíduos,

veja nas Figuras 5.5 e 5.6, enquanto que o algoritmo de Viterbi com 2-níveis de

checkpoints por linhas provocou atividade excessiva de paginação para seqüências de

512.000 resíduos, veja nas Figuras 5.5 e 5.6.

Os algoritmos propostos 1 e 2 tiveram desempenhos semelhantes em relação aos tempos

de CPU e tempos totais de execução no intervalo de 2.000 a 512.000 resíduos, veja a

Tabela 5.6 e as Figuras 5.5 e 5.6. Enquanto, o algoritmo de Viterbi com 2-níveis de

checkpoints por diagonais e o algoritmo por linhas, também, desempenharam de forma

semelhante até o ponto em que o algoritmo por diagonais exauriu os recursos de

memória do PC, ou seja, para seqüências no intervalo de 2.000 a 32.000 resíduos.

1 10 100 1000 10000 2 4 8 _{16 32 64} 12⁸ 25⁶ 51²

Tamanhos das seqüências (x 1000 radicais)

Tempos totais de execução (segundos)

Viterbi Básico

2-níveis Checkpoints Linha

2-níveis Checkpoints Bidimensional 1 2-níveis Checkpoints Bidimensional 2 2-níveis Checkpoints Diagonal

FIGURA 5.6 – Tempos totais de execução dos algoritmos de Viterbi para alinhamentos

de seqüências de aminoácidos a um HMM com 2000 nós (eixos

logarítmicos).

O algoritmo de Viterbi com 2-níveis de checkpoints por linhas e os algoritmos propostos

1 e 2 tiveram comportamento bastante semelhante no intervalo considerado, até que o

algoritmo por linhas exaurisse os recursos de memória do PC, o que ocorreu para

seqüências com 512.000 resíduos, veja a Tabela 5.6 e as Figuras 5.5 e 5.6. Pode-se notar

que os algoritmos propostos 1 e 2 foram ~2 vezes mais rápidos do que o algoritmo de

Viterbi com 2-níveis de checkpoints por linhas, no intervalo correspondendo a

seqüências com 2.000 a 256.000 resíduos.

0,00 10,00 20,00 30,00 40,00 50,00 60,00 70,00 80,00 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 Tamanhos das seqüência (x 1000 radicais)

Tempos de CPU (segundos)

Viterbi Básico

2-níveis Checkpoints Linha

2-níveis Checkpoints Bidimensional 1 2-níveis Checkpoints Bidimensional 2 2-níveis Checkpoints Diagonais

FIGURA 5.7 – Tempos de CPU dos algoritmos Viterbi para alinhamento de seqüências

de aminoácidos a um HMM com 2000 nós.

Nota-se, também, observando as Figuras 5.3, 5.4, 5.5 e 5.6, que os algoritmos propostos

1 e 2 tiveram desempenhos similares no alinhamento de seqüências a um HMM com

2.000 nós, em todo o intervalo considerado, quase sempre com uma leve vantagem em

desempenho para o algoritmo proposto 2. É importante salientar que esse ganho em

desempenho, mesmo que por um fator muito pequeno é uma informação significativa,

pois o algoritmo proposto 2 usa menos memória e efetua mais re-computações que o

algoritmo proposto 1 e, logo, deveria sofrer uma queda de desempenho maior. Talvez

isto se deva ao fato que o algoritmo proposto 2 divida a matriz de PD em um número 4

vezes menor de seções do que o algoritmo proposto 1 e, portanto, tire mais proveito do

retrocedimento restrito. O que ressalta o comportamento, até intuitivo, do uso de

procedimentos de retrocedimento restrito nesses algoritmos com checkpoints é que: o

aumento da memória disponível para uma determinada instância do problema provoca

uma redução no ganho de performance adicional devido ao uso do retrocedimento

restrito, ou alternativamente, a redução da memória disponível para uma determinada

instância do problema provoca um aumento no ganho de performance adicional devido

ao uso do retrocedimento restrito.

0,00 50,00 100,00 150,00 200,00 250,00 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32

Tamanhos das seqüência (x 1000 radicais)

Te mpso totais de e xe cu ção (se gundos) Viterbi Básico

2-níveis Checkpoints Linha

2-níveis Checkpoints Bidimensional 1 2-níveis Checkpoints Bidimensional 2 2-níveis Checkpoints Diagonais

FIGURA 5.8 – Tempos totais de execução dos algoritmos Viterbi para alinhamento de

seqüências de aminoácidos a um HMM com 2000 nós.

É importante comparar esses resultados com aqueles obtidos nos experimentos de

Tarnas e Hughey (1998), para análise do comportamento de algoritmos de programação

dinâmica usados na computação de medidas de interesse em HMMs. Nesses

experimentos seqüências de aminoácidos menores do que ou iguais a 10.000 resíduos

são utilizadas em computações com o algoritmo de Viterbi, ambos com e sem

checkpoints. O uso significativo de memória virtual pelos algoritmos de programação

dinâmica básicos inicia-se para seqüências maiores do que 7.000 resíduos e tornam-se

críticos para seqüências maiores do que 8.000 resíduos. Eles consideram o algoritmo de

Viterbi básico e o com 2-níveis de checkpoints por diagonais e retrocedimento restrito,

que é justamente o algoritmo alvo com o qual se deseja comparar os algoritmos com

2-níveis de checkpoints bidimensionais 1 e 2, propostos nesse trabalho.

Para uma melhor comparação visual dos dados obtidos no conjunto de testes do

experimento 1 deste trabalho com aqueles obtidos por Tarnas e Hughey (1998) em seus

experimentos, foram elaborados dois gráficos, veja Figuras 5.7 e 5.8, com os dados em

valores absolutos, referentes aos dados sintetizados na Tabela 5.5, além daqueles

normalizados (básico = 1) mostrados nas Figuras 5.3 e 5.4. Os resultados obtidos por

Tarnas e Hughey (1998) são apresentados nas Figuras 5.9 e 5.10 e foram extraídos da

Figura 3 do trabalho deles.

FIGURA 5.9 – Tempos de CPU para efetuar 4 execuções de computações de

programação dinâmica de seqüências de aminoácidos contra um HMM

com 500 nós.

FONTE: Extraído da Figura 3 de Tarnas e Hughey (1998).

Os comportamentos obtidos no experimento 1 desta tese apresentam diferenças

significativas, com relação às medidas dos tempos de execução, daqueles obtidos por

Tarnas e Hughey (1998), na comparação com o algoritmo de Viterbi básico. Os

experimentos efetuados nesse estudo indicaram que o algoritmo de Viterbi com 2-níveis

de checkpoints por diagonais apresentaram queda de desempenho, em relação ao

algoritmo de Viterbi básico, por um fator de ~1,8 no intervalo anterior ao início de

atividade de paginação siginificativa, tanto para os tempos de CPU quanto para os

tempos totais de execução. Nesses experimentos, após o início de atividade significativa

de paginação pelo algoritmo de Viterbi básico, o algoritmo de Viterbi com 2-níveis de

checkpoints por diagonais apresentou um ganho de desempenho por um fator de ~1,4

para os tempos de CPU e de até ~5,0 para os tempos totais de execução. Ao passo que

os experimentos em Tarnas e Hughey (1998) apresentaram desempenhos bastante

próximos para os tempos de CPU em todo o intervalo considerado e para os tempos

totais de execução até o início de atividade de paginação siginificativa. Apresentaram

ganho de perfomance do algoritmo por diagonais sobre o básico, por um fator de até

~10 vezes para os tempos totais de execução, após o início de atividade de paginação

siginificativa. Veja a Tabela 5.5 e as Figuras 5.7, 5.8, 5.9 e 5.10.

FIGURA 5.10 – Tempos totais de execução para efetuar 4 execuções de computações

de programação dinâmica de seqüências de aminoácidos contra um

No documento ALGORITMOS DE PROGRAMAÇÃO DINÂMICA USADOS EM MODELOS MARKOVIANOS OCULTOS (HMMs) (páginas 163-187)