Ao analisar atentamente o algoritmo 5.1, foi poss´ıvel observar que ap´os as inicializac¸˜oes, praticamente todas as etapas podem ser executadas em paralelo, `a excec¸˜ao daquelas descritas entre as linhas 9 e 13, bem como entre as linhas 23 e 27, onde os so- mat´orios dos quadrados dos elementos de Y BX e dos elementos de MS s˜ao realizados para o c´alculo de S e Q(ˆx). Estas etapas devem ser executadas serialmente, em func¸˜ao das vari´aveis somaY BX2 e somaMS, uma vez que o acesso concorrente a estas prejudica- ria significativamente o desempenho da abordagem paralela implementada neste trabalho. As demais etapas, por outro lado, correspondem a operac¸˜oes realizadas sobre pixels in- dividualmente, o que as tornam excelentes candidatas `a paralelizac¸˜ao, sendo cada thread respons´avel pela computac¸˜ao sobre um pixel.
O algoritmo paralelo proposto foi desenvolvido para mover toda a informac¸˜ao ne- cess´aria `a execuc¸˜ao para a mem´oria global da GPU na inicializac¸˜ao, minimizando assim o tr´afego de dados entre a CPU e a GPU durante a execuc¸˜ao de seu loop principal, o que poderia comprometer criticamente o desempenho da aplicac¸˜ao. Em raz˜ao da dependˆencia de dados descrita em 5.4.1, a execuc¸˜ao paralela ´e realizada por dois kernels.
O primeiro kernel calcula a convoluc¸˜ao da matriz de borramento b sobre ˆx e os ele- mentos das matrizes Y BX e MS correspondentes `a thread em execuc¸˜ao, de forma a permitir o c´alculo de S e Q(ˆx), e corresponde aos trechos do algoritmo 5.1 entre as linhas 6 e 8, e entre as linhas 20 e 22. A estrutura do kernel paralelo conv dif ´e apresentada de maneira simplificada no algoritmo abaixo:
Algoritmo 5.2: Implementac¸˜ao simplificada do kernel conv dif Entrada: y[], ˆx[], x[], b[], normaB[], α, q
Sa´ıda: Y BX[], MS[] Inicializac¸˜ao:
1: i ← Id thread 2: j ← Id bloco
Efetua c´alculos:
3: Calcula Y BXi,j (eq. 5.18)
4: Calcula MSi,j (eq. 5.21)
5: retorna
O segundo kernel realiza os c´alculos dos elementos correspondentes `a thread em execuc¸˜ao das derivadas primeira e segunda, Fr,s e Fn,m, da correc¸˜ao ∆ˆx, aplicando-a
sobre ˆx para obter a nova estimativa de imagem restaurada, e corresponde aos trechos do algoritmo 5.1 entre as linhas 15 e 19. A estrutura do kernel aplica deltaX ´e tamb´em apresentada de maneira simplificada no algoritmo que segue.
Uma definidos ambos os kernels conv dif e aplica deltaX, o processo de restaurac¸˜ao paralela proposto ´e apresentado no algoritmo 5.4. A principal caracter´ıstica
Algoritmo 5.3: Implementac¸˜ao simplificada do kernel aplica deltaX Entrada: ˆxt[], x[], b[], normaB[], S2BB[], α, q, γ Sa´ıda: ˆxt+1[] Inicializac¸˜ao: 1: r ← Id thread 2: s ← Id bloco Efetua c´alculos: 3: Calcula Fr,s (eq. 5.20) 4: Calcula Fn,m (eq. 5.17) 5: Calcula ˆxr,s (eq. 5.10) 6: retorna
deste algoritmo ´e transferir, em sua inicializac¸˜ao, todas as informac¸˜oes necess´arias `a sua execuc¸˜ao para a mem´oria global da GPU, de forma a evitar transferˆencias de dados ex- cessivas, o que pode comprometer drasticamente o desempenho da execuc¸˜ao. Os passos sublinhados correspondem `as transferˆencias entre CPU e GPU e, dentro do loop principal, se limitam `as buscas das matrizes Y BX e MS usadas para o c´alculo serial de Q(ˆx). Es- tas matrizes s˜ao alocadas na mem´oria principal como espac¸o n˜ao-pagin´avel (page-locked memory), de forma a reduzir o tempo de transferˆencia, conforme descrito em 3.3.
A estrutura de blocos e threads de ambos os kernels foi estabelecida para computar os resultados de uma linha por bloco e um elemento (pixel) por thread. Ainda que os dados estejam alocados na mem´oria global, esta estrutura favorece o acesso usando o cache da GPU, o que oculta os elevados tempos de acesso em comparac¸˜ao com n´ıveis mais baixos de mem´oria. Isso ´e poss´ıvel em raz˜ao de as threads acessarem a mem´oria global em posic¸˜oes sequenciais, respeitando a localidade dos dados e permitindo o acesso coalescente, conforme descrito em 3.4.2.
A complexidade do algoritmo paralelo proposto ´e O(n3), em raz˜ao da substituic¸˜ao dos
dois loops secund´arios pelos kernels. De fato, considerando-se o loop principal (O(n)), ambos os kernels (O(n2)), os somat´orios (O(n2)) e as demais operac¸˜oes (O(1)), tem-se
O(n× (n2 + n2 + n2 + 1 + 1 + 1 + 1 + 1)) = O(n3). Entretanto, deve-se levar em considerac¸˜ao que apesar de os kernels possu´ırem complexidade O(n2), esta ´e devida aos
loops de convoluc¸˜oes utilizando a matriz de borramento, cujas dimens˜oes s˜ao em geral consideravelmente menores que as dimens˜oes das imagens, o que torna o custo computa- cional destas operac¸˜oes pequeno, apesar da complexidade. Al´em disso, dada a natureza e quantidade das operac¸˜oes matem´aticas executadas nos trechos paralelizados, pode-se se dizer que a maioria das operac¸˜oes executadas no algoritmo serial foram paralelizadas com sucesso, restando apenas somat´orios e verificac¸˜oes para serem executados serialmente.
Finalmente, apesar de a verificac¸˜ao de convergˆencia ser uma etapa necess´aria para garantir a correic¸˜ao dos resultados, ela pode ser evitada em aplicac¸˜oes onde s˜ao realiza- das restaurac¸˜oes em tempo real, com um n´umero fixo e reduzido de iterac¸˜oes, um dos
Algoritmo 5.4: Restaurac¸˜ao paralela de imagens por regularizac¸˜ao de Tikhonov Entrada: y[], dim b, σ2, α, q, γ, N
Sa´ıda: ˆx[], Q(ˆx) Inicializac¸˜ao:
1: Calcula b (eq. 5.2)
2: Calcula normaB (eq. 5.14)
3: Calcula S2BB (eq. 5.16)
4: xˆ← y
5: x← y
6: Envia y, ˆx, x, b, normaB e S2BB para a GPU
C´alculo inicial de Q(ˆx):
7: Executa conv dif (alg. 5.2)
8: Busca Y BX e MS da GPU
9: para i = 0 → (M − 1); j = 0 → (M − 1) 10: somaY BX2 ← somaY BX2 + Y BXi,j2 11: somaM S ← somaMS + MSi,j
12: fim para
13: Calcula S (eq. 5.24)
14: Calcula Q0(ˆx) (eq. 5.19)
Loop principal:
15: para t = 0 → (N − 1)
Calcula nova estimativa:
16: Executa aplica deltaX (alg. 5.3)
Calcula o novo valor de Q(ˆx):
17: Executa conv dif (alg. 5.2)
18: Busca Y BX e MS da GPU
19: para i = 0 → (M − 1); j = 0 → (M − 1) 20: somaY BX2← somaY BX2 + Y BXi,j2
21: somaM S ← somaMS + MSi,j
22: fim para
23: Calcula S (eq. 5.24)
24: Calcula Q1(ˆx) (eq. 5.19)
Verifica convergˆencia:
25: se Q1(ˆx) > Q0(ˆx)ent˜ao interrompa
Atribui valores para a pr´oxima iterac¸˜ao:
26: x← ˆx
27: Q0(ˆx)← Q1(ˆx)
28: fim para
29: Busca ˆx da GPU 30: retorna
focos principais deste trabalho. Nestes casos, o resultado da restaurac¸˜ao ´e exibido ime- diatamente, e o usu´ario define em tempo de execuc¸˜ao os parˆametros de restaurac¸˜ao que resultam nos melhores resultados. O cap´ıtulo 6 apresenta os resultados da avaliac¸˜ao do desempenho dos algoritmos nos casos em que a verificac¸˜ao de convergˆencia ´e aplicada ou n˜ao.
Cap´ıtulo 6
Resultados e discuss˜ao
Os objetivos deste trabalho foram fornecer ferramentas para composic¸˜ao, exibic¸˜ao e restaurac¸˜ao de imagens obtidas por microscopia de forc¸a atˆomica com o melhor de- sempenho poss´ıvel, de forma a permitir o emprego destas em aplicac¸˜oes de exibic¸˜ao de resultados em tempo real, sem deixar de lado, contudo, a qualidade da imagens apresen- tadas. Desta forma foram avaliados tanto o desempenho como a qualidade das aplicac¸˜oes desenvolvidas.
O desenvolvimento do trabalho se deu atrav´es do desenvolvimento em paralelo de duas ferramentas, que em seu estado atual ainda n˜ao operam em conjunto. Isso se deve ao fato de que enquanto que o programa de restaurac¸˜ao ´e facilmente execut´avel em qual- quer computador que possua uma placa gr´afica compat´ıvel com a tecnologia CUDA, o que ´e relativamente simples de se encontrar no mercado, a ferramenta de exibic¸˜ao de imagens foi desenvolvida como um objetivo secund´ario, para uma aplicac¸˜ao muito mais espec´ıfica, n˜ao necessariamente sendo aplic´avel a todas as tecnologias de microscopia de forc¸a atˆomica dispon´ıveis. N˜ao obstante, a integrac¸˜ao das ferramentas ´e perfeitamente vi´avel, e ´e apresentada como uma das propostas de trabalhos futuros, dentre outras.
Todos os testes de execuc¸˜ao foram realizados em notebook dotado de um processador Intel i7 de segunda gerac¸˜ao com 2,20 GHz de clock, 6 GB de mem´oria RAM DDR3, e uma GPU GeForce GT555M com 2 GB de mem´oria e 144 n´ucleos com 1,05 GHz de clock, operando com o driver CUDA vers˜ao 5.0. Todos os programas foram escritos para serem executados em Windows 7, em linguagem C/C++, no ambiente de desenvolvimento Visual Studio 2012 (ou adaptados para este ambiente, no caso das vers˜oes desenvolvidas em trabalhos anteriores), sendo a dll respons´avel pela integrac¸˜ao da ferramenta com o programa de controle do AFM descrito no cap´ıtulo 4 escrita em linguagem C# no mesmo ambiente de desenvolvimento.
Os programas executados serialmente foram escritos usando vari´aveis de ponto flutu- ante de precis˜ao dupla (double), uma vez que foi observado que eles s˜ao executados mais rapidamente nestas condic¸˜oes em arquiteturas de 64 bits, e utilizando a opc¸˜ao -O2 como parˆametro de compilac¸˜ao. Os algoritmos paralelos, por sua vez, foram escritos utilizando
vari´aveis de ponto flutuante de precis˜ao simples (float).
Todos os tempos de execuc¸˜ao apresentados nas avaliac¸˜oes de desempenho corres- pondem a m´edias aritm´eticas de 10 execuc¸˜oes alternadas, como medida de compensar eventuais flutuac¸˜oes no desempenho global do sistema durante os testes. Por exemplo, ao avaliar dois algoritmos, executa-se o primeiro e o segundo em sequˆencia, repetindo esse processo 10 vezes para computar as m´edias.
6.1 Ferramenta de exibic¸˜ao de imagens
Uma vez que a configurac¸˜ao do microsc´opio de forc¸a atˆomica em uso no IBCCF atualmente produz apenas imagens de 128x128 ou 256x256 pixels, como o exemplo da figura 6.1, foi necess´ario o uso de diferentes conjuntos de dados representando diferentes imagens de teste criadas especificamente para o prop´osito de avaliar adequadamente o desempenho da ferramenta de exibic¸˜ao de imagens para dimens˜oes maiores que as dis- pon´ıveis. A figura 6.2 exibe a visualizac¸˜ao de uma imagem artificial de 256x256 pixels.
A avaliac¸˜ao da ferramenta consistiu em comparar os tempos de execuc¸˜ao da mesma quando executada serialmente e em paralelo, atrav´es de CUDA. A aplicac¸˜ao paralela foi
Figura 6.1: Exemplo de visualizac¸˜ao 3D de uma imagem com 256x256 pixels de uma grade de teste obtida com o uso de um AFM.
Figura 6.2: Visualizac¸˜ao 3D de um conjunto de dados representando uma imagem artificialmente criada com 256x256 pixels.
avaliada em diferentes vers˜oes, onde cada uma delas apresenta uma metodologia distinta de alocac¸˜ao e acesso `a mem´oria principal do sistema, a saber, a alocac¸˜ao tradicional da biblioteca C (malloc), a alocac¸˜ao de mem´oria n˜ao-pagin´avel (page-locked memory), e o mapeamento da mem´oria n˜ao-pagin´avel diretamente pela GPU (zero-copy). Os gr´aficos das figuras 6.3 e 6.4 exibem os tempos de processamento de 500 conjuntos de dados, o que corresponde `a exibic¸˜ao de 500 imagens, para cada uma das abordagens empregadas, enquanto o gr´afico da figura 6.5 exibe os ganhos, ou acelerac¸˜oes (speedups), de cada abordagem paralela, em comparac¸˜ao com a abordagem serial. O ganho ´e definido como:
g = tr ta
, (6.1)
onde tr e ta s˜ao respectivamente os tempos de execuc¸˜ao observados em um programa
usado como referˆencia e os tempos do programa sob an´alise. Neste trabalho, os ga- nhos ser˜ao sempre apresentados tomando-se como referˆencia o programa executado seri- almente em CPU.
Figura 6.3: Tempos de execuc¸˜ao da ferramenta de exibic¸˜ao para imagens de 128x128 e 256x256 pixels.
Figura 6.4: Tempos de execuc¸˜ao da ferramenta de exibic¸˜ao para imagens de 512x512 e 1024x1024 pixels.
da abordagem serial ´e superior ao das demais abordagens, em virtude do elevado custo das chamadas `a API CUDA para transferˆencias de pequenos conjuntos de dados, bem como para a execuc¸˜ao dos trˆes kernels, em comparac¸˜ao com as computac¸˜ao executada. O gr´afico da figura 6.6 ilustra o impacto do tr´afego de dados CPU↔GPU no tempo total de processamento. Al´em disso, para imagens pequenas, o desempenho da CPU ´e favorecido pelo uso do cache da mesma. Conforme an´alise feita no cap´ıtulo 4, j´a era esperado que a pequena quantidade de operac¸˜oes realizadas em paralelo por cada thread dos kernels poderia ser um obst´aculo `a paralelizac¸˜ao da aplicac¸˜ao, especialmente para imagens de dimens˜oes reduzidas.
`A medida que as dimens˜oes das imagens aumentam, por outro lado, o desempenho das abordagens paralelas v˜ao, uma a uma, se mostrando superiores ao desempenho da abordagem serial. Ao analisar o gr´afico da figura 6.6, pode-se inferir que `a medida que o tr´afego de dados deixa de impactar significativamente no tempo total de processamento
Figura 6.5: Ganhos de desempenho (speedups) decorrentes da paralelizac¸˜ao da ferramenta de exibic¸˜ao.
Figura 6.6: Raz˜ao percentual do tempo consumido com tr´afego de dados nas abordagens paralelas.
da aplicac¸˜ao CUDA o desempenho da mesma aumenta.
Apesar de, dentre as abordagens paralelas empregadas, a que apresentou o melhor de- sempenho foi aquela que emprega o mapeamento de mem´oria diretamente pela GPU, esta pr´atica deve ser adotada com cautela. A t´ecnica de zero-copy ´e empregada com sucesso em casos particulares, onde as leituras/escritas s˜ao realizadas com pouca frequˆencia, em comparac¸˜ao com a computac¸˜ao efetuada, devido ao custo elevado de se realizar estas operac¸˜oes. Al´em disso ela ´e mais indicada para sistemas onde a GPU ´e integrada, usual- mente compartilhando a mem´oria com a CPU [21], o que ´e o caso do sistema empregado nesta avaliac¸˜ao. Nos demais casos, a abordagem usando mem´oria n˜ao pagin´avel poderia a mais indicada. De fato, apenas os vetores contendo os dados do fotodetetor e da correc¸˜ao em z, bem como suas respectivas imagens parciais, foram alocados atrav´es da t´ecnica de zero-copy, sendo os demais dados alocados como mem´oria n˜ao-pagin´avel, uma vez que esta abordagem foi a que proporcionou os melhores resultados.