Processamento de Sinal através do GPU

Transcrição

1 Processamento de Sinal através do GPU Relatório Final do Projecto Informático n.º 15/ , ei15888 Relatório final submetido para avaliação parcial da unidade curricular de Projecto Informático, do curso de Engenharia Informática. Projecto sob a orientação do Professor Gustavo Reis, do Departamento de Engenharia Informática da Escola Superior de Tecnologia e Gestão do Instituto Politécnico de Leiria. Departamento de Engenharia Informática da Escola Superior de Tecnologia e Gestão do Instituto Politécnico de Leiria 8 de Julho de 2008

2 Proposta de Projecto Nos dias de hoje, o poder computacional do GPU (Graphics Processing Unit) é superior ao poder computacional do próprio CPU do computador, sendo cada vez mais comum a implementação de aplicações e de rotinas matemáticas bastante pesadas no processador gráfico, para um maior ganho de performance. A NVIDIA desenvolveu uma biblioteca para este efeito denominada de CUDA (Compute Unified Device Architecture, ver que permite a um programador a codificação de algoritmos em C ou C++ que serão posteriormente executados no GPU. O objectivo deste projecto é a implementação de um algoritmo genético simples, onde seja gerado um sinal áudio e que este evolua até ser praticamente igual ao sinal áudio pretendido, como na transcrição automática de música. O trabalho será desenvolvido em C ou C++ e utilizando a biblioteca CUDA, da NVIDIA para a parte de processamento de sinal.

3 Resumo O objectivo deste projecto foi criar uma pequena biblioteca de funções que auxiliem aplicações de tratamento de sinal a trabalharem no GPU (Graphics Processing Unit), isto porque algumas dessas funções são computacionalmente onerosas quando executadas no CPU (Central Processing Unit). À medida que se implementaram as funções necessárias estas foram comparadas com o MATLAB 1 e IPP 2, tanto a nível de resultados como de desempenho, a correrem essas mesmas funções. Após a criação destas funções fizeram-se vários benchmarks para ajudar na escolha da arquitectura das funções e para verificar se os resultados obtidos valeram o esforço dedicado ao projecto. Os benchmarks de performance foram efectuados comparando o desempenho no CPU com a biblioteca IPP e no GPU com a biblioteca deste projecto. No final podemos inferir que valeu a pena o trabalho havendo ganhos muito significativos com os novos algoritmos em muitas situações, embora em alguns casos o CPU continue a ser preferível. 1 MATLAB (MATrix LABoratory) é um software interactivo de alta performance voltado para o cálculo numérico. 2 IPP - Intel Integrated Performance Primitives (Intel IPP) é uma extensa biblioteca de funções de software optimizadas para processamento de dados multimédia e aplicações de comunicações

4

5 Índice 1 Introdução Tecnologias e ferramentas utilizadas Hardware Software Funções a criar Funções de operações vectoriais Funções de janelas Funções específicas de processamento de sinal Modelo de paralelização Blocos de threads Grelhas de blocos de threads Modelo de paralelização escolhido Trabalho Efectuado Alternativas ao modelo de paralelização Número de threads Funções criadas Considerações gerais Alocação de Arrays Transferência de dados Libertar memória FFT Forward e Inverse Auto-correlação... 23

6 2.3.7 Funções de operações vectoriais Memória partilhada Funções de janelas Exemplo de utilização Problemas e extras Resultados Conclusão Trabalho futuro Bibliografia Anexos Placas gráficas que suportam CUDA SDK Funções criadas Alocação de arrays Transferência de dados Libertar memória FFT Forward e Inverse Autocorrelação Funções de operações vectoriais Memória partilhada Funções de janelas... 46

7 1 Introdução Tendo em conta o objectivo inicial deste projecto a implementação de um algoritmo genético simples, onde seja gerado um sinal áudio e que este evolua até ser praticamente igual ao sinal audio pretendido, como na transcrição automática de música foi efectuada uma revisão bibliográfica sobre as funções de processamento de sinal existentes implementadas sobre a arquitectura do GPU e estudo comparativo sobre a viabilidade das mesmas. Após a revisão concluiu-se que existia uma lacuna e que apenas havia rotinas de processamento de sinal implementadas na arquitecutra do CPU (como é o caso do IPP). Assim sendo, e com o objectivo de colmatar essa lacuna, o âmbito do projecto foi ligeiramente alterado, onde o principal objectivo passou a ser a criação de uma biblioteca genérica que implementasse sobre a arquitectura do GPU várias funções de processamento de sinal. Posto isto seria feito um estudo comparativo em relação outras implementações das mesmas, sobre o CPU. O paralelismo massivo do GPU (analisado de seguida) permite que as rotinas matemáticas a implementar sejam executadas de forma muito rápida em relação a um CPU de apenas 1, 2 ou 4 núcleos dado que uma placa gráfica a um preço acessível contém até 16 núcleos, embora tenha uma frequência de operação menor que cada núcleo do CPU. Figura 1 Evolução do número de operações de virgula flutuante por segundo no GPU e CPU Projecto Informático, DEI ESTG IPLEIRIA 7 de 50

8 Para programar no GPU pela plataforma CUDA é utilizada a linguagem C leccionada no curso de Engenharia Informática, mas foi necessário estudar a documentação do CUDA e os projectos amostrais para entender a arquitectura de memória e utilização correcta dos multi-processadores do GPU. Para a aplicação de testes foi necessário aprender C++, linguagem não integrada no currículo de Engenharia Informática, e aprender a utilizar as MFC 3 para a interface gráfica. É possível utilizar o CUDA SDK tanto em windows como em linux, mas optou-se pela plataforma windows com Visual Studio 2005 dado que é visualmente mais agradável e simples de configurar e integrar. No fim, o código fonte da biblioteca pode ser compilado em qualquer sistema operativo com suporte para o CUDA SDK, isto porque as MFC (específicas para Windows) não foram utilizadas nas funções da biblioteca, apenas na interface gráfica de testes. No fim deste projecto pretende-se verificar se as funções construídas para o GPU têm um desempenho superior às mesmas no CPU, com o objectivo de tornar o processamento de sinal mais célere, dado que é um campo de programação muito pesado computacionalmente. 3 As MFC (Microsoft Foundation Classes) são uma colecção de classes em C++ que podem ser usadas na construção de aplicações, ajudam especialmente a programar a interface gráfica da aplicação Projecto Informático, DEI ESTG IPLEIRIA 8 de 50

9 1.1 Tecnologias e ferramentas utilizadas Hardware Para este projecto foi utilizado um computador com um CPU Intel single core a 3.2 Ghz e uma placa gráfica NVIDIA GeForce 8800 GT. Apenas algumas das placas gráficas da NVIDIA possuem suporte para a plataforma CUDA e esta é uma delas (ver Anexo 1). Esta placa gráfica tem as seguintes características: Core Clock (MHz) 600 MHz Shader Clock (MHz) 1500 MHz Memory Clock (MHz) 900 MHz Memory Amount 512MB Memory Interface 256-bit Memory Bandwidth (GB/sec) 57.6 Texture Fill Rate (billion/sec) 33.6 G80 Arquitechture Multiprocessors 14 Processors per Multiprocessor 8 Stream Processors 112 Projecto Informático, DEI ESTG IPLEIRIA 9 de 50

10 1.1.2 Software Para este projecto foram utilizados vários programas e bibliotecas de funções discriminados de seguida. Visual Studio 2005 Este é o principal IDE (Integrated Development Environment) da Microsoft. Foi utilizado devido à integração fácil com as restantes bibliotecas a serem utilizadas e por ser fácil de usar e familiar ao programador. ICC (Intel C++ Compiler) Este compilador foi utilizado ao invés do compilador C++ da Microsoft que vem com o Visual Studio pois optimiza o programa em várias zonas principalmente nas relacionadas com multi-threading ou multi-core. MFC (Microsoft Foundation Classes) A biblioteca MFC é uma colecção de classes em C++ que podem ser usadas na construção de aplicações. Esta biblioteca poupa muito tempo aos programadores ao disponibilizar código previamente escrito e que serve em grande parte das aplicações. Existem classes MFC para todos os elementos de uma interface gráfica de utilizador (janelas, paineis, menus, barras de ferramentas, barras de estado, etc), para fazer interfaces com bases de dados, para gerir eventos tais como mensagens de outras aplicações, gerir o input do rato e teclado ou criar controlos ActiveX. IPP (Integrated Performance Primitives) Intel Integrated Performance Primitives (Intel IPP) é um conjunto de bibliotecas de funções de software optimizadas para processamento de dados multimédia e aplicações de comunicações. As bibliotecas presentes no IPP são a IPPCP dedicada a Criptografia, IPPI para processamento de imagens e vídeo, IPPM para operações sobre matrizes e por fim a IPPS que serve para processamento de sinal, sendo esta a biblioteca a utilizar neste projecto para comparação de performance e resultados com as funções criadas com o CUDA. WaveFormat Biblioteca C/C++ para leitura de ficheiros de som.wav para um vector Projecto Informático, DEI ESTG IPLEIRIA 10 de 50

11 LinePlot Biblioteca C/C++ para criação de gráficos simples para visualizar resultados FFTW Biblioteca C/C++ para o processamento de FFT em qualquer processador. Dado que a biblioteca IPP apenas funciona com processadores Intel achou-se por bem comparar resultados com uma biblioteca genérica, para qualquer processador. CUDA SDK O CUDA SDK (Compute Unified Device Architecture - Software Development Kit) permite a programação no GPU e possui integração com o Visual Studio para o seu compilador. Apenas necessita de um ou mais ficheiros.cu com o código para o GPU a ser compilado no NVCC (Nvidia C Compiler). Foi utilizada principalmente a biblioteca CUFFT deste SDK. Projecto Informático, DEI ESTG IPLEIRIA 11 de 50

12 1.2 Funções a criar Funções de operações vectoriais Todas estas funções possuem versões para diferentes tipos de dados, inteiros e floats. CuMul As funções desta família multiplicam um a um os dados de dois vectores cusum As funções desta família somam um a um os dados de dois vectores cusub As funções desta família subtraem um a um os dados de dois vectores cuarraysum As funções desta família somam todos os dados de um vector para uma variável. Apenas funcionam com tamanhos de vector que sejam potências de 2 para poder demonstrar a utilização ao máximo de memória partilhada. cumagnitude Esta função calcula o módulo de todos os valores de um vector de números complexos saida = raizquadrada( entradareal ^ 2 * entradaimaginaria ^ 2 ) cusetcomplexfromreal Esta função coloca os valores de um array de floats na parte real de um array de complexos e mete a parte imaginária a 0. cuset As funções desta família colocam todos os blocos de um array com um mesmo valor cudivscalar As funções desta família dividem todos os dados de um vector por um número Projecto Informático, DEI ESTG IPLEIRIA 12 de 50

13 cumulscalar As funções desta família multiplicam todos os dados de um vector por um número Funções de janelas Estas funções aplicam uma janela a um vector de dados. Essa janela é aplicada utilizando a função da janela respectiva no vector de dados de entrada e multiplicando os valores da janela pelos dados de entrada. Saida = entrada * janela(entrada) Estas funções também possuem versões para os dois tipos de dados, inteiros e floats. cuhamming As funções desta família aplicam uma janela de Hamming ao vector de dados de entrada. Função de Hamming: Figura 2 Exemplo da janela de Hamming Projecto Informático, DEI ESTG IPLEIRIA 13 de 50

14 cuhann As funções desta família aplicam uma janela de Hann ao vector de dados de entrada. Função de Hann: Figura 3 Exemplo duma janela de Hann Funções específicas de processamento de sinal cufft Esta função aplica a Fast Fourier Transform a um vector de dados de um sinal. A FFT é uma função de grande importância para uma larga variedade de aplicações, desde o processamento de sinal ao cálculo de derivadas parciais. A função em si já está implementada e optimizada no CUDA SDK na biblioteca CUFFT. Foram implementadas a FFT directa (real para complexo) e inversa (complexo para real). AutoCorr A Auto-Correlação é uma ferramenta matemática para encontrar padrões repetidos, tais como a presença de um sinal periódico que possui ruído ou a identificação da Projecto Informático, DEI ESTG IPLEIRIA 14 de 50

15 frequência fundamental de um sinal pelas suas harmónicas. A abordagem utilizada na implementação diz-nos que a auto-correlação de um sinal é igual à FFT inversa do quadrado do módulo da FFT directa desse sinal. Projecto Informático, DEI ESTG IPLEIRIA 15 de 50

16 1.3 Modelo de paralelização Dado que a placa gráfica utilizada neste trabalho possui uma grande quantidade de núcleos processadores foi óbvio que se teria de aproveitar essas potencialidades sempre que possível. Após leitura do CUDA Programming Guide[1] foram tidas em conta as seguintes recomendações patentes nesse documento: Cada processador gráfico está dividido em blocos de threads até um máximo de e cada bloco pode levar até 512 threads. (ver Figura 1) Projecto Informático, DEI ESTG IPLEIRIA 16 de 50

17 Figura 4 um kernel (função) do Device (GPU) é chamado pelo Host (CPU) e executado numa grelha de blocos de threads (ver secção e 1.3.2) Para arrays unidimensionais é recomendado que cada thread calcule 1 único valor do array por causa do coalescing 4. A NVIDIA recomenda que o número de threads seja múltiplo do warp size 5 que é 32 no processador gráfico G80 A placa gráfica possui memória partilhada entre threads de um mesmo bloco. Esta memória será útil apenas para a família de funções cuarraysum dado que o valor da soma é o mesmo para todo o vector. 4 Caso as threads consecutivas utilizem espaços de memória consecutivos, em vez de ser feita uma leitura para cada thread, é feita uma leitura para um conjunto de dados contíguos que preencha o buffer de dados da placa gráfica em questão sendo depois divididos pelas threads respectivas. Assim há menos transferências de dados, logo maior performance. 5 Conjunto de threads processadas ao mesmo tempo Projecto Informático, DEI ESTG IPLEIRIA 17 de 50

18 O uso de registos pode ajudar quando forem necessárias 2 leituras à mesma zona de memória global, ou seja a criação de uma variável dentro do contexto da thread para guardar a parte de memória global a ser acedida várias vezes (ver Figura 2) Figura 5 - Modelo de memória do GPU Neste projecto não é utilizada memória de textura. Este tipo de memória é importante para trabalhos que requiram primitivas gráficas Blocos de threads Um bloco de threads é um conjunto de threads que podem cooperar ao partilharem dados eficientemente através de memória partilhada de rápido acesso e sincronizando a sua execução para coordenar acessos à memória. Mais especificamente, pode-se definir pontos de sincronização no kernel 6 onde as threads de um bloco ficam suspensas até que todas elas cheguem ao ponto de sincronização. Este método está patente nas funções cuarraysum dado que utilizam memória partilhada que necessita destes pontos de sincronização. 6 Denomina-se por kernel neste projecto uma função global executada no GPU Projecto Informático, DEI ESTG IPLEIRIA 18 de 50

19 Cada thread é identificada pelo seu thread ID que é o seu número de thread dentro de um bloco. Para ajudar com endereçamentos complexos baseados no thread ID, uma aplicação pode especificar um bloco como um array de duas ou três dimensões de tamanho arbitrário e identificar a thread utilizando indíces de dois ou três componentes. Por exemplo, para um bloco de duas dimensões de tamanho (Dx, Dy) o thread ID de uma thread no índice (x, y) é (x + y.dx) e para um bloco de três dimensões de tamanho (Dx, Dy, Dz) o thread ID de uma thread no índice (x, y, z) é (x + y.dx + z.dx.dy). Neste projecto, como os arrays a utilizar são unidimensionais, os blocos de threads também têm apenas uma dimensão Grelhas de blocos de threads Há um número máximo de threads que um bloco pode conter (512). No entanto, blocos com a mesma dimensão e tamanho que executam um mesmo kernel podem ser juntos numa grelha de blocos para que o número de threads numa invocação do kernel seja muito superior. Isto tem o custo de uma menor cooperação entre threads, porque threads em diferentes blocos da mesma grelha não podem comunicar nem sincronizar umas com as outras. Para ajudar com endereçamentos complexos baseados no block ID, uma aplicação pode especificar uma grelha como um array de duas dimensões de tamanho arbitrário e identificar o bloco utilizando indíces de dois componentes. Por exemplo, para uma grelha de duas dimensões de tamanho (Dx, Dy) o block ID de um bloco no índice (x, y) é (x + y.dx) Modelo de paralelização escolhido Tendo em conta todos os dados recolhidos e explicados previamente resolveu-se fazer com que um bloco tenha N_THREADS múltiplo de 32 (warpsize) e inferior a 512 e que seja alocada uma grelha de blocos com número de blocos igual a TamanhoVector / N_THREADS, para ser calculado um valor do vector em cada thread. Projecto Informático, DEI ESTG IPLEIRIA 19 de 50

20 Figura 6 modelo de separação de dados por threads É também recomendado que o número de amostras seja uma potência de 2 para preencher todas as threads e blocos totalmente e ter performance máxima, embora todos os algoritmos, excepto as funções cuarraysum, funcionem com qualquer número de amostras. Inclusivé a função FFT que não é aceite em algumas bibliotecas com tamanho diferente de uma potência de 2 pode ser feita no CUDA com qualquer tamanho. Este modelo reflecte a arquitectura SPMD (Single Program Multiple Device) que se quer para os algoritmos deste projecto, dado que é uma única função a ser executado em vários processadores concorrentemente. Este modelo de paralelização foi utilizado nas funções de operações vectoriais e de janelas. Projecto Informático, DEI ESTG IPLEIRIA 20 de 50

21 segundos Processamento de sinal no GPU 2 Trabalho Efectuado 2.1 Alternativas ao modelo de paralelização Foram estudadas alternativas, para diminuir a criação de threads, em que em vez de cada thread trabalhar com apenas uma amostra trabalhava com duas ou quatro. Os resultados desse estudo podem ser visualizados na imagem seguinte dado por thread 2 dados por thread 4 dados por thread N_SAMPLES Figura 7 Gráfico de comparação dos vários modelos de threads Como se pode verificar, a utilização de apenas uma amostra por thread foi melhor em todos os tamanhos, menos nas 8192 amostras, e assim sendo foi o método utilizado em todo o trabalho, tomando-se a excepção por descartável. Isto acontece porque as leituras à memória global da placa gráfica demoram mais tempo do que a própria criação de threads, assim, tendo o mínimo de leituras à memória global aumentamos a performance do algoritmo. Como o número de leituras à memória global é directamente proporcional ao número de amostras utilizado por cada thread, há um mínimo de leituras quando o número de amostras por thread é também mínimo, ou seja apenas uma amostra por thread. Projecto Informático, DEI ESTG IPLEIRIA 21 de 50

22 segundos Processamento de sinal no GPU 2.2 Número de threads Outro estudo que se fez foi do número de threads a utilizar, utilizou-se a função cumul chamada em iterações num vector de amostras Tempo N_THREADS Figura 8 Gráfico de comparação de performance com alteração do número de threads As funções implementadas nesta biblioteca que utilizam threads são muito simples, pelo que o gráfico anterior não é conclusivo. O threading deverá melhorar significativamente a performance em funções mais onerosas que não foram abordadas neste trabalho. Ainda assim, podemos verificar que com um número de threads não múltiplo de 32 os tempos de execução disparam pois a utilização da memória e processamento da placa gráfica não é o óptimo. Verifica-se isto quando foram utilizadas 16 e 255 threads. Visto que não foi possível concluir com este estudo qual o melhor número de threads, foi escolhido utilizar 256 threads pois é o número médio de threads suportadas e é múltiplo de 32. Projecto Informático, DEI ESTG IPLEIRIA 22 de 50

23 2.3 Funções criadas Todas as funções criadas podem ser consultadas nos Anexos. Estão organizadas da mesma forma que esta secção de modo a serem facilmente identificadas. No ínicio de cada secção de funções não específicas do CUDA é apresentado o protótipo da função no IPP para se poder comparar e verificar que são muito parecidos, para uma rápida transição das pessoas que trabalham com IPP para a biblioteca deste projecto Considerações gerais #define IMUL(a, b) mul24(a, b) Esta linha no início do código especifica que a multiplicação de inteiros IMUL será feita a 24 bits. Foi implementado desta forma pois a maioria dos vectores de inteiros utilizados não deverão ter números que ocupem 24 bits ou mais e porque assim melhora-se a performance do programa, pois no processador um mul 32 bits faz-se em 16 ciclos de relógio e um mul 24 bits faz-se em 4 ciclos de relógio. Na documentação as funções afectadas por esta medida terão uma referência para que sejam utilizadas as funções Float para inteiros maiores que 24 bits. Um cufftcomplex é basicamente uma estrutura de dois floats para representar um número complexo, um float para a parte real e outro para a parte imaginária. Uma função começada por extern C pode ser chamada por uma aplicação externa C/C++ e uma função começada por global define o código que cada thread do GPU processa nas variáveis Device Alocação de Arrays extern "C" void allocatefloatarray(float **arr, int len){ CUDA_SAFE_CALL(cudaMalloc((void**)arr, len*sizeof(float))); Estas funções servem para alocar arrays dos vários tipos utilizados por esta biblioteca. É necessário chamar estas funções para arrays de Device (GPU) Transferência de dados extern "C" void floatarrayhtod(float *host, float *device,int len){ CUDA_SAFE_CALL(cudaMemcpy(device, host, len*sizeof(float), cudamemcpyhosttodevice)); Projecto Informático, DEI ESTG IPLEIRIA 23 de 50

24 extern "C" void intarraydtoh(int *device, int *host,int len){ CUDA_SAFE_CALL(cudaMemcpy(host, device, len*sizeof(int), cudamemcpydevicetohost)); Para copiar dados que tenhamos no CPU para o GPU, ou seja, de arrays Host para o Device ou vice-versa. Foram criadas funções HtoD e DtoH para todos os tipos de dados utilizados. Dados de Device não podem ser alterados fora de funções global, daí ser necessário copiar os dados para o Host sempre que se quer fazer uma operação não implementada nesta biblioteca. As funções HtoD e DtoH devem ser chamadas o menor número de vezes possível pois são muito pesadas, dado que implicam a transferência de dados do CPU para o GPU, o óptimo será chamar cada uma apenas uma vez num kernel dado que esse é o mínimo para se utilizar esta biblioteca Libertar memória extern "C" void freearray(void *device){ CUDA_SAFE_CALL(cudaFree(device)); Esta função serve para libertar memória de qualquer array de Device alocado com a família de funções allocate...array. Deve ser chamada sempre que um array Device deixa de ser necessário FFT Forward e Inverse extern "C" void cufft_forward(float *srcdevice,cufftcomplex *dstdevice, int len){ cuffthandle plan; CUFFT_SAFE_CALL(cufftPlan1d(&plan, len, CUFFT_R2C, 1)); CUFFT_SAFE_CALL(cufftExecR2C(plan, srcdevice, dstdevice)); CUFFT_SAFE_CALL(cufftDestroy(plan)); extern "C" void cufft_inverse(cufftcomplex *srcdevice,float *dstdevice, int len){ cuffthandle plan; CUFFT_SAFE_CALL(cufftPlan1d(&plan, len, CUFFT_C2R, 1)); CUFFT_SAFE_CALL(cufftExecC2R(plan, srcdevice, dstdevice)); Projecto Informático, DEI ESTG IPLEIRIA 24 de 50

25 CUFFT_SAFE_CALL(cufftDestroy(plan)); Para executar uma FFT é necessário criar um plano respectivo para depois executar. De Real para Complex a FFT é implicitamente Forward, ou para a frente, e de Complex para Real é implicitamente Inverse, ou para trás. Uma FFT Inverse do resultado de uma Forward dá o vector de entrada da Forward e vice-versa Auto-correlação Protótipo IPP: IppStatus ippsautocorr_32f(const Ipp32f* psrc, int srclen, Ipp32f* pdst, int dstlen); Função CUDA: extern "C" void autocorr(float *srcdevice,float *dstdevice, int len){ cufftcomplex *d_complex; allocatecufftcomplexarray(&d_complex,len); cufft_forward(srcdevice,d_complex,len); dim3 dimblock; dim3 dimgrid; dimblock = dim3(len); dimgrid = dim3(1); else{ dimblock = dim3(n_threads); dimgrid = dim3(len/n_threads); cumag_d<<<dimgrid,dimblock>>>(d_complex, dstdevice,len); cumulf_d<<<dimgrid,dimblock>>>(dstdevice,dstdevice, dstdevice,len); len); setcomplexfromreal_d<<<dimgrid,dimblock>>>(d_complex,dstdevice, cufft_inverse(d_complex,dstdevice,len); len); cudivscalarf_d<<<dimgrid,dimblock>>>(dstdevice,len,dstdevice, freearray(d_complex); Projecto Informático, DEI ESTG IPLEIRIA 25 de 50

26 A implementação da função de auto-correlação reflecte o que foi dito sobre ela na introdução. Por causa da implementação da FFT do CUDA é necessário dividir todos os dados do vector final pelo seu tamanho para obter resultados fidedignos. dimblock = dim3(len); dimgrid = dim3(1); else{ dimblock = dim3(n_threads); dimgrid = dim3(len/n_threads); Este código está presente em todas as funções que requerem funcionamento com threads. Serve para proteger a aplicação no caso do tamanho do vector ser inferior ao número de threads por defeito, em que é alocada uma grelha de um bloco com número de threads igual ao tamanho passado por parâmetro. cumag_d<<<dimgrid,dimblock>>>(d_complex, dstdevice,len); Esta chamada de função mostra como são chamadas funções globais do Device (GPU). Apenas nestas funções se podem fazer operações em variáveis do Device. São dados o tamanho da grelha de blocos e o número de threads de cada bloco para o GPU dividir as operações Funções de operações vectoriais Protótipo IPP: IppStatus ippsmagnitude_32fc(const Ipp32fc* psrc, Ipp32f* pdst, int len); Função CUDA: extern "C" void cumagnitude(cufftcomplex *srcdevice, float *dstdevice, int len){ dim3 dimblock; dim3 dimgrid; dimblock = dim3(len); dimgrid = dim3(1); else{ dimblock = dim3(n_threads); dimgrid = dim3(len/n_threads); cumag_d<<<dimgrid,dimblock>>>(srcdevice, dstdevice,len); global void cumag_d(cufftcomplex *src,float *dst,int len){ Projecto Informático, DEI ESTG IPLEIRIA 26 de 50

27 int tx = blockidx.x * N_THREADS + threadidx.x; if (tx < len) { cufftcomplex block = src[tx]; dst[tx]=sqrtf((block.x*block.x) + (block.y*block.y)); Cada função de operações vectoriais tem uma primeira função de chamada que faz a ponte entre a aplicação C++ e o código do GPU, define o número de threads e blocos e chama o kernel respectivo. int tx = blockidx.x * N_THREADS + threadidx.x; O indíce do vector é dado pelo thread ID + block ID * tamanhobloco tal como explicado no modelo de paralelização e na teoria de blocos de threads Memória partilhada Protótipo IPP: IppStatus ippssum_64f(const Ipp64f* psrc, int len, Ipp64f* psum); Função CUDA: extern "C" int cuarraysumi(int *srcdevice,int len){ int numblocks, numthreads; numthreads = len; numblocks = 1; else{ numthreads = N_THREADS; numblocks =len/n_threads; dim3 dimgrid(numblocks); dim3 dimblock(numthreads); int smemsize = numthreads * sizeof(float); int *dstdevice; allocateintarray(&dstdevice,numblocks); cuarraysumi_d<<<dimgrid,dimblock,smemsize>>>(srcdevice, dstdevice); int *dsthost = (int *) malloc(numblocks*sizeof(int)); intarraydtoh(dstdevice,dsthost,numblocks); int sum = 0; Projecto Informático, DEI ESTG IPLEIRIA 27 de 50

28 for(int i=0; i<numblocks; i++) { sum += dsthost[i]; free(dsthost); freearray(dstdevice); return sum; Nas funções cuarraysum entra mais um parâmetro em jogo por causa da memória partilhada. SmemSize diz ao kernel qual o tamanho do array de memória partilhada, que neste caso é um array com o tamanho de cada bloco, ou seja, o número de threads de cada bloco, com o tipo de dados respectivo. Como a memória partilhada é só entre threads de um mesmo bloco, temos de arranjar um vector auxiliar para guardar a soma de cada bloco de threads e no fim somar todos os valores desse vector no Host para obter o resultado final. global void cuarraysumi_d(int *srcdevice, int *dstdevice) { extern shared int shdata[]; // load shared mem unsigned int tid = threadidx.x; unsigned int i = blockidx.x*blockdim.x + threadidx.x; shdata[tid] = srcdevice[i]; syncthreads(); // do reduction in shared mem for(unsigned int s=blockdim.x/2; s>0; s>>=1) { if (tid < s) { shdata[tid] += shdata[tid + s]; syncthreads(); // write result for this block to global mem if (tid == 0) dstdevice[blockidx.x] = shdata[0]; O passo da soma é um shift à direita, ou seja, soma 128, 64, 32,..., 2 para cada thread da primeira metade do bloco e assim no fim temos o indíce 0 do vector de memória partilhada com a soma dos dados do bloco. Por causa desta implementação que dá grande ênfase à memória partilhada e à paralelização as funções cuarraysum apenas funcionam correctamente para tamanhos de amostras que sejam potências de 2. Projecto Informático, DEI ESTG IPLEIRIA 28 de 50

29 2.3.9 Funções de janelas Protótipo IPP: IppStatus ippswinhann_16s(const Ipp16s* psrc, Ipp16s* pdst, int len); Função CUDA: extern "C" void cuhanni(int *srcdevice,int *dstdevice,int len){ dim3 dimblock; dim3 dimgrid; dimblock = dim3(len); dimgrid = dim3(1); else{ dimblock = dim3(n_threads); dimgrid = dim3(len/n_threads); //we calculate the Hann values hannvaluesi_d<<<dimgrid,dimblock>>>(srcdevice,dstdevice,len); cumuli_d<<<dimgrid,dimblock>>>(srcdevice,dstdevice,dstdevice, len); Tal como foi dito na introdução, a janela é obtida calculando os valores de janela dos dados de entrada e multiplicando esses valores pelos dados de entrada. global void hannvaluesi_d(int *src,int *dst, int len){ int tx = blockidx.x * N_THREADS + threadidx.x; if (tx < len) { dst[tx] = *cosf(2*PI*src[tx]/len); No kernel é aplicada a função da janela a cada dado do vector de entrada. O endereçamento é feito da mesma forma que as funções de operações vectoriais Exemplo de utilização Se quisermos que a nossa aplicação C++ calcule uma FFT de um sinal e faça a sua magnitude o código será deste género com a biblioteca deste projecto: float *h_float = (float *) malloc(len * sizeof(float)); cufftcomplex *d_complex; float *d_float; for(int i=0; i<len; i++) Projecto Informático, DEI ESTG IPLEIRIA 29 de 50

30 h_float[i] = dados[i]; allocatecufftcomplexarray(d_complex,len); allocatefloatarray(d_float,len); floatarrayhtod(h_float, d_float,len); cufft_forward(d_float, d_complex, len); cumagnitude(d_complex, d_float, len); floatarraydtoh(d_float, h_float, len); Como se pode ver torna-se bastante simples e intuitivo para quem esteja habituado a trabalhar em C/C++ com a biblioteca IPP ou mesmo para quem se esteja a iniciar. 3 Problemas e extras As funcionalidades pedidas foram todas implementadas sem problemas e ainda foi implementada a função de auto correlação que não estava nos planos iniciais. 4 Resultados Para comparar resultados testaram-se três funções implementadas, a função cufft que calcula os valores de uma FFT aplicada a um sinal, a função autocorr que calcula os valores da auto correlação de um sinal e a função cumulf que multiplica todos os elementos de dois vectores de floats um a um, as duas primeiras devido a sua complexidade e a última como representante das funções de operações em vectores. A função cufft foi comparada com a respectiva função da biblioteca IPP e também com a FFTW, uma outra biblioteca dedicada a FFT, enquanto que as outras duas funções foram apenas comparadas com as respectivas funções da biblioteca IPP. As funções testadas da biblioteca deste projecto foram chamadas um certo número de vezes a partir da aplicação de teste C++ patente na descrição de cada teste. Projecto Informático, DEI ESTG IPLEIRIA 30 de 50

31 segundos segundos Processamento de sinal no GPU cumul ippmul N_SAMPLES Figura 9 - Resultados da função cumulf em IPP e CUDA com variação do tamanho de amostras ( iterações) autocorr ippautocorr N_SAMPES Figura 10 - Resultados da função autocorr em IPP e CUDA com variação do tamanho de amostras (10000 iterações) Projecto Informático, DEI ESTG IPLEIRIA 31 de 50

32 segundos Processamento de sinal no GPU ippfft cufft FFTW N_SAMPLES Figura 11 - Resultados da função cufft em IPP, CUDA e FFTW com variação do tamanho de amostras (20000 iterações) Todas as funções testadas levam a uma mesma conclusão deste projecto, que para tamanhos de amostras grandes a nossa biblioteca tem ganhos significativos enquanto que para tamanhos de amostras pequenos as outras bibliotecas estudadas levam vantagem. A biblioteca implementada tinha como objectivo auxiliar o desenvolvimento de aplicações de tratamento de sinal. Ora como podemos ver o CPU leva grande vantagem para tamanhos pequenos de amostras mas a nossa biblioteca é mais eficaz em tamanhos grandes. Isto deve-se principalmente ao factor de ligação CPU/GPU pois a mudança de contexto demora muito tempo em relação ao ganho que existe no processamento. Pode-se verificar isto pois o crescimento do tempo de execução dos algoritmos da nossa biblioteca é linear, ou seja, as mudanças de contexto continuam a ser sempre as mesmas mas o processamento aumenta ligeiramente com o aumento do número de amostras. Por outro lado, o crescimento do tempo de execução dos algoritmos IPP é exponencial indicando que a complexidade da execução não aumenta regularmente com o aumento do número de amostras, mas sim mais do que isso, enquanto o aumento de tempo com a biblioteca criada é linear e inferior à proporcionalidade com o número de amostras. Por outras palavras, o aumento de amostras leva a um aumento de processamento muito superior no CPU em relação ao GPU. Projecto Informático, DEI ESTG IPLEIRIA 32 de 50

33 A causa principal para esta situação é o massivo paralelismo do GPU. Com milhares de threads a processarem concorrentemente o GPU consegue uma produção de resultados muito superior ao CPU. Pode-se definir o tamanho de amostras como o mínimo para os programadores que pretendam utilizar a nossa biblioteca, dado que as funções mais complexas já têm um desempenho superior e as funções mais simples (de operações vectoriais) não estão longe da performance do IPP. 5 Conclusão O objectivo principal desta biblioteca era servir para os programadores de processamento de sinal melhorarem as suas aplicações. Para programadores que utilizem amostras muito grandes este objectivo foi atingido, embora para os programadores que trabalhem com tamanhos de amostras relativamente pequenos a biblioteca IPP continua a levar vantagem. Se analisarmos as funções criadas podemos inferir que a sua complexidade não é muito elevada, embora a compreensão da arquitectura do GPU e sua utilização correcta sejam mais complexas. Assim, é recomendado que qualquer programador que possa tomar algum tempo a compreender a programação com a plataforma CUDA faça a transcrição directa do seu algoritmo para o GPU, assim aproveitando ao máximo as capacidades do GPU sem muitas mudanças de contexto com o CPU. Para aqueles que não possuem esse tempo e utilizem tamanhos de amostras grandes esta biblioteca pode ser uma boa ajuda para o seu programa. Projecto Informático, DEI ESTG IPLEIRIA 33 de 50

34 6 Trabalho futuro A própria biblioteca implementada não possui grandes hipóteses de melhoramentos, a não ser as funções cuarraysum, mas se forem alteradas para funcionar com qualquer tamanho terá performance inferior à actual para potências de 2. Podem sim ser desenvolvidas novas funções no mesmo âmbito deste projecto e serem adicionadas à biblioteca. Dado que este foi um trabalho pioneiro na instituição do IPL ao trabalhar com a plataforma CUDA fica a recomendação para propostas de projecto futuras que pretendam utilizar esta plataforma: As funções a programar nesta plataforma devem ser complexas e possuir a possibilidade de paralelizar no total ou perto os seus algoritmos. Só assim se consegue fazer valer o potencial do GPU e dos seus inúmeros núcleos e atingir resultados bastante superiores aos obtidos no CPU. Projecto Informático, DEI ESTG IPLEIRIA 34 de 50

35 7 Bibliografia Intel Integrated Performance Primitives (Intel IPP) - Intel IPP Source Code Examples CodeGuru: A 2D Lite Graph Control with Multiple Plot Support Cross Correlation NVIDIA CUDA Programming Guide NVIDIA Forums Intel C++ Compiler FFTW homepage Hann and Hamming Windows wikipedia FFT CUDA homepage Projecto Informático, DEI ESTG IPLEIRIA 35 de 50

36 8 Anexos 8.1 Placas gráficas que suportam CUDA SDK Placas gráficas que suportam o CUDA SDK, o número de multi-processadores em cada placa gráfica e a versão de CUDA SDK suportada (1.0 ou 1.1): Projecto Informático, DEI ESTG IPLEIRIA 36 de 50

37 8.2 Funções criadas Alocação de arrays extern "C" void allocatefloatarray(float **arr, int len){ CUDA_SAFE_CALL(cudaMalloc((void**)arr, len*sizeof(float))); extern "C" void allocateintarray(int **arr, int len){ CUDA_SAFE_CALL(cudaMalloc((void**)arr, len*sizeof(int))); extern "C" void allocatecufftcomplexarray(cufftcomplex **arr, int len){ CUDA_SAFE_CALL(cudaMalloc((void**)arr, len*sizeof(cufftcomplex))); Transferência de dados Host to Device extern "C" void floatarrayhtod(float *host, float *device,int len){ CUDA_SAFE_CALL(cudaMemcpy(device, host, len*sizeof(float), cudamemcpyhosttodevice)); extern "C" void intarrayhtod(int *host, int *device,int len){ CUDA_SAFE_CALL(cudaMemcpy(device, host, len*sizeof(int), cudamemcpyhosttodevice)); extern "C" void cufftcomplexarrayhtod(cufftcomplex *host, cufftcomplex *device,int len){ CUDA_SAFE_CALL(cudaMemcpy(device, host, len*sizeof(cufftcomplex), cudamemcpyhosttodevice)); Device to Host extern "C" void cufftcomplexarraydtoh(cufftcomplex *device, cufftcomplex *host,int len){ CUDA_SAFE_CALL(cudaMemcpy(host, device, len*sizeof(cufftcomplex), cudamemcpydevicetohost)); Projecto Informático, DEI ESTG IPLEIRIA 37 de 50

38 extern "C" void floatarraydtoh(float *device, float *host,int len){ CUDA_SAFE_CALL(cudaMemcpy(host, device, len*sizeof(float), cudamemcpydevicetohost)); extern "C" void intarraydtoh(int *device, int *host,int len){ CUDA_SAFE_CALL(cudaMemcpy(host, device, len*sizeof(int), cudamemcpydevicetohost)); Libertar memória extern "C" void freearray(void *arr){ CUDA_SAFE_CALL(cudaFree(arr)); FFT Forward e Inverse extern "C" void cufft_forward(float *srcdevice,cufftcomplex *dstdevice, int len){ cuffthandle plan; CUFFT_SAFE_CALL(cufftPlan1d(&plan, len, CUFFT_R2C, 1)); CUFFT_SAFE_CALL(cufftExecR2C(plan, srcdevice, dstdevice)); CUFFT_SAFE_CALL(cufftDestroy(plan)); extern "C" void cufft_inverse(cufftcomplex *srcdevice,float *dstdevice, int len){ cuffthandle plan; CUFFT_SAFE_CALL(cufftPlan1d(&plan, len, CUFFT_C2R, 1)); CUFFT_SAFE_CALL(cufftExecC2R(plan, srcdevice, dstdevice)); CUFFT_SAFE_CALL(cufftDestroy(plan)); Autocorrelação extern "C" void autocorr(float *srcdevice,float *dstdevice, int len){ cufftcomplex *d_complex; allocatecufftcomplexarray(&d_complex,len); cufft_forward(srcdevice,d_complex,len); Projecto Informático, DEI ESTG IPLEIRIA 38 de 50

39 dim3 dimblock; dim3 dimgrid; dimblock = dim3(len); dimgrid = dim3(1); else{ dimblock = dim3(n_threads); dimgrid = dim3(len/n_threads); cumag_d<<<dimgrid,dimblock>>>(d_complex, dstdevice,len); cumulf_d<<<dimgrid,dimblock>>>(dstdevice,dstdevice, dstdevice,len); len); setcomplexfromreal_d<<<dimgrid,dimblock>>>(d_complex,dstdevice, cufft_inverse(d_complex,dstdevice,len); len); cudivscalarf_d<<<dimgrid,dimblock>>>(dstdevice,len,dstdevice, freearray(d_complex); Funções de operações vectoriais cumagnitude extern "C" void cumagnitude(cufftcomplex *srcdevice, float *dstdevice,int len){ dim3 dimblock; dim3 dimgrid; dimblock = dim3(len); dimgrid = dim3(1); else{ dimblock = dim3(n_threads); dimgrid = dim3(len/n_threads); cumag_d<<<dimgrid,dimblock>>>(srcdevice, dstdevice,len); global void cumag_d(cufftcomplex *src,float *dst,int len){ int tx = blockidx.x * N_THREADS + threadidx.x; if (tx < len) { cufftcomplex block = src[tx]; dst[tx]=sqrtf((block.x*block.x) + (block.y*block.y)); Projecto Informático, DEI ESTG IPLEIRIA 39 de 50

40 cusum extern "C" void cusumi(int *src1device, int *src2device, int *dstdevice,int len){ dim3 dimblock; dim3 dimgrid; dimblock = dim3(len); dimgrid = dim3(1); else{ dimblock = dim3(n_threads); dimgrid = dim3(len/n_threads); ); cusumi_d<<<dimgrid,dimblock>>>(src1device,src2device,dstdevice,len global void cusumi_d(int *src1,int *src2,int *dst,int len){ int tx = blockidx.x * N_THREADS + threadidx.x; if (tx < len) { dst[tx]=src1[tx]+src2[tx]; extern "C" void cusumf(float *src1device, float *src2device, float *dstdevice,int len){ dim3 dimblock; dim3 dimgrid; dimblock = dim3(len); dimgrid = dim3(1); else{ dimblock = dim3(n_threads); dimgrid = dim3(len/n_threads); ); cusumf_d<<<dimgrid,dimblock>>>(src1device,src2device,dstdevice,len global void cusumf_d(float *src1,float *src2,float *dst,int len){ int tx = blockidx.x * N_THREADS + threadidx.x; if (tx < len) { dst[tx]=src1[tx]+src2[tx]; Projecto Informático, DEI ESTG IPLEIRIA 40 de 50

41 cusub extern "C" void cusubi(int *src1device, int *src2device, int *dstdevice,int len){ dim3 dimblock; dim3 dimgrid; dimblock = dim3(len); dimgrid = dim3(1); else{ dimblock = dim3(n_threads); dimgrid = dim3(len/n_threads); ); cusubi_d<<<dimgrid,dimblock>>>(src1device,src2device,dstdevice,len global void cusubi_d(int *src1,int *src2,int *dst,int len){ int tx = blockidx.x * N_THREADS + threadidx.x; if (tx < len) { dst[tx]=src1[tx]-src2[tx]; extern "C" void cusubf(float *src1device, float *src2device, float *dstdevice,int len){ dim3 dimblock; dim3 dimgrid; dimblock = dim3(len); dimgrid = dim3(1); else{ dimblock = dim3(n_threads); dimgrid = dim3(len/n_threads); ); cusubf_d<<<dimgrid,dimblock>>>(src1device,src2device,dstdevice,len global void cusubf_d(float *src1,float *src2,float *dst,int len){ int tx = blockidx.x * N_THREADS + threadidx.x; if (tx < len) { dst[tx]=src1[tx]-src2[tx]; Projecto Informático, DEI ESTG IPLEIRIA 41 de 50

42 cumul extern "C" void cumuli(int *src1device, int *src2device, int *dstdevice,int len){ dim3 dimblock; dim3 dimgrid; dimblock = dim3(len); dimgrid = dim3(1); else{ dimblock = dim3(n_threads); dimgrid = dim3(len/n_threads); ); cumuli_d<<<dimgrid,dimblock>>>(src1device,src2device,dstdevice,len global void cumuli_d(int *src1,int *src2,int *dst,int len){ int tx = blockidx.x * N_THREADS + threadidx.x; if (tx < len) { dst[tx]=imul(src1[tx],src2[tx]); extern "C" void cumulf(float *src1device, float *src2device, float *dstdevice,int len){ dim3 dimblock; dim3 dimgrid; dimblock = dim3(len); dimgrid = dim3(1); else{ dimblock = dim3(n_threads); dimgrid = dim3(len/n_threads); ); cumulf_d<<<dimgrid,dimblock>>>(src1device,src2device,dstdevice,len global void cumulf_d(float *src1,float *src2,float *dst,int len){ int tx = blockidx.x * N_THREADS + threadidx.x; if (tx < len) { dst[tx]=src1[tx]*src2[tx]; Projecto Informático, DEI ESTG IPLEIRIA 42 de 50

43 cumulscalar extern "C" void cumulscalari(int *srcdevice, int scalar, int *dstdevice,int len){ dim3 dimblock; dim3 dimgrid; dimblock = dim3(len); dimgrid = dim3(1); else{ dimblock = dim3(n_threads); dimgrid = dim3(len/n_threads); cumulscalari_d<<<dimgrid,dimblock>>>(srcdevice,scalar,dstdevice,le n); global void cumulscalari_d(int *src1,int scalar,int *dst,int len){ int tx = blockidx.x * N_THREADS + threadidx.x; if (tx < len) { dst[tx]=imul(src1[tx],scalar); extern "C" void cumulscalarf(float *srcdevice, float scalar, float *dstdevice,int len){ dim3 dimblock; dim3 dimgrid; dimblock = dim3(len); dimgrid = dim3(1); else{ dimblock = dim3(n_threads); dimgrid = dim3(len/n_threads); cumulscalarf_d<<<dimgrid,dimblock>>>(srcdevice,scalar,dstdevice,le n); global void cumulscalarf_d(float *src1,float scalar,float *dst,int len){ int tx = blockidx.x * N_THREADS + threadidx.x; if (tx < len) { dst[tx]=src1[tx]*scalar; Projecto Informático, DEI ESTG IPLEIRIA 43 de 50

44 cudivscalar extern "C" void cudivscalari(int *srcdevice, int scalar, int *dstdevice,int len){ dim3 dimblock; dim3 dimgrid; dimblock = dim3(len); dimgrid = dim3(1); else{ dimblock = dim3(n_threads); dimgrid = dim3(len/n_threads); cudivscalari_d<<<dimgrid,dimblock>>>(srcdevice,scalar,dstdevice,le n); global void cudivscalari_d(int *src1,int scalar,int *dst,int len){ int tx = blockidx.x * N_THREADS + threadidx.x; if (tx < len) { dst[tx]=src1[tx]/scalar; extern "C" void cudivscalarf(float *srcdevice, float scalar, float *dstdevice,int len){ dim3 dimblock; dim3 dimgrid; dimblock = dim3(len); dimgrid = dim3(1); else{ dimblock = dim3(n_threads); dimgrid = dim3(len/n_threads); cudivscalarf_d<<<dimgrid,dimblock>>>(srcdevice,scalar,dstdevice,le n); global void cudivscalarf_d(float *src1,float scalar,float *dst,int len){ int tx = blockidx.x * N_THREADS + threadidx.x; if (tx < len) { dst[tx]=src1[tx]/scalar; Projecto Informático, DEI ESTG IPLEIRIA 44 de 50

45 cuset extern "C" void cuseti(int *srcdevice,int number,int len){ dim3 dimblock; dim3 dimgrid; dimblock = dim3(len); dimgrid = dim3(1); else{ dimblock = dim3(n_threads); dimgrid = dim3(len/n_threads); cuseti_d<<<dimgrid,dimblock>>>(srcdevice,number,len); global void cuseti_d(int *src,int number,int len){ int tx = blockidx.x * N_THREADS + threadidx.x; if (tx < len) { src[tx]=number; extern "C" void cusetf(float *srcdevice,float number,int len){ dim3 dimblock; dim3 dimgrid; dimblock = dim3(len); dimgrid = dim3(1); else{ dimblock = dim3(n_threads); dimgrid = dim3(len/n_threads); cusetf_d<<<dimgrid,dimblock>>>(srcdevice,number,len); global void cusetf_d(float *src,float number,int len){ int tx = blockidx.x * N_THREADS + threadidx.x; if (tx < len) { src[tx]=number; extern "C" void cusetcomplexfromreal(cufftcomplex *srcdevice,float *src2device, int len){ dim3 dimblock; dim3 dimgrid; Projecto Informático, DEI ESTG IPLEIRIA 45 de 50

46 dimblock = dim3(len); dimgrid = dim3(1); else{ dimblock = dim3(n_threads); dimgrid = dim3(len/n_threads); cusetcomplexfromreal_d<<<dimgrid,dimblock>>>(srcdevice, src2device, len); global void cusetcomplexfromreal_d(cufftcomplex *src,float *src2,int len){ int tx = blockidx.x * N_THREADS + threadidx.x; if (tx < len) { src[tx].x=src2[tx]; src[tx].y=0; Memória partilhada extern "C" int cuarraysumi(int *srcdevice,int len){ int numblocks, numthreads; numthreads = len; numblocks = 1; else{ numthreads = N_THREADS; numblocks =len/n_threads; dim3 dimgrid(numblocks); dim3 dimblock(numthreads); int smemsize = numthreads * sizeof(float); int *dstdevice; allocateintarray(&dstdevice,numblocks); cuarraysumi_d<<<dimgrid,dimblock,smemsize>>>(srcdevice,dstdevice); int *dsthost = (int *) malloc(numblocks*sizeof(int)); intarraydtoh(dstdevice,dsthost,numblocks); int sum = 0; for(int i=0; i<numblocks; i++) { sum += dsthost[i]; free(dsthost); freearray(dstdevice); return sum; Projecto Informático, DEI ESTG IPLEIRIA 46 de 50

47 global void cuarraysumi_d(int *srcdevice, int *dstdevice) { extern shared int shdata[]; // load shared mem unsigned int tid = threadidx.x; unsigned int i = blockidx.x*blockdim.x + threadidx.x; shdata[tid] = srcdevice[i]; syncthreads(); // do reduction in shared mem for(unsigned int s=blockdim.x/2; s>0; s>>=1) { if (tid < s) { shdata[tid] += shdata[tid + s]; syncthreads(); // write result for this block to global mem if (tid == 0) dstdevice[blockidx.x] = shdata[0]; extern "C" float cuarraysumf(float *srcdevice,int len){ int numblocks, numthreads; numthreads = len; numblocks = 1; else{ numthreads = N_THREADS; numblocks =len/n_threads; dim3 dimgrid(numblocks); dim3 dimblock(numthreads); int smemsize = numthreads * sizeof(float); float *dstdevice; allocatefloatarray(&dstdevice,numblocks); cuarraysumf_d<<<dimgrid,dimblock,smemsize>>>(srcdevice,dstdevice); float *dsthost = (float *) malloc(numblocks*sizeof(float)); floatarraydtoh(dstdevice,dsthost,numblocks); float sum = 0; for(int i=0; i<numblocks; i++) { sum += dsthost[i]; free(dsthost); freearray(dstdevice); return sum; global void cuarraysumf_d(float *srcdevice, float *dstdevice) { Projecto Informático, DEI ESTG IPLEIRIA 47 de 50

48 extern shared float sdata[]; // load shared mem unsigned int tid = threadidx.x; unsigned int i = blockidx.x*blockdim.x + threadidx.x; sdata[tid] = srcdevice[i]; syncthreads(); // do reduction in shared mem for(unsigned int s=blockdim.x/2; s>0; s>>=1) { if (tid < s) { sdata[tid] += sdata[tid + s]; syncthreads(); // write result for this block to global mem if (tid == 0) dstdevice[blockidx.x] = sdata[0]; Funções de janelas cuhann extern "C" void cuhanni(int *srcdevice,int *dstdevice,int len){ dim3 dimblock; dim3 dimgrid; dimblock = dim3(len); dimgrid = dim3(1); else{ dimblock = dim3(n_threads); dimgrid = dim3(len/n_threads); //we calculate the Hann values hannvaluesi_d<<<dimgrid,dimblock>>>(srcdevice,dstdevice,len); cumuli_d<<<dimgrid,dimblock>>>(srcdevice,dstdevice,dstdevice,len); global void hannvaluesi_d(int *src,int *dst, int len){ int tx = blockidx.x * N_THREADS + threadidx.x; if (tx < len) { dst[tx] = *cosf(2*PI*src[tx]/len); extern "C" void cuhannf(float *srcdevice,float *dstdevice,int len){ dim3 dimblock; dim3 dimgrid; dimblock = dim3(len); dimgrid = dim3(1); Projecto Informático, DEI ESTG IPLEIRIA 48 de 50