Processamento de Sinal através do GPU

Tamanho: px
Começar a partir da página:

Download "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

PARALELIZAÇÃO DE APLICAÇÕES NA ARQUITETURA CUDA: UM ESTUDO SOBRE VETORES 1

PARALELIZAÇÃO DE APLICAÇÕES NA ARQUITETURA CUDA: UM ESTUDO SOBRE VETORES 1 PARALELIZAÇÃO DE APLICAÇÕES NA ARQUITETURA CUDA: UM ESTUDO SOBRE VETORES 1 DUTRA, Evandro Rogério Fruhling 2 ; VARINI, Andre Luis 2 ; CANAL, Ana Paula 2 1 Trabalho de Iniciação Científica _UNIFRA 2 Ciência

Leia mais

Arquitetura e Programação de GPU. Leandro Zanotto RA: 001962 Anselmo Ferreira RA: 023169 Marcelo Matsumoto RA: 085973

Arquitetura e Programação de GPU. Leandro Zanotto RA: 001962 Anselmo Ferreira RA: 023169 Marcelo Matsumoto RA: 085973 Arquitetura e Programação de GPU Leandro Zanotto RA: 001962 Anselmo Ferreira RA: 023169 Marcelo Matsumoto RA: 085973 Agenda Primeiras Placas de Vídeo Primeira GPU Arquitetura da GPU NVIDIA Arquitetura

Leia mais

Programação em Paralelo. N. Cardoso & P. Bicudo. Física Computacional - MEFT 2010/2011

Programação em Paralelo. N. Cardoso & P. Bicudo. Física Computacional - MEFT 2010/2011 Programação em Paralelo CUDA N. Cardoso & P. Bicudo Física Computacional - MEFT 2010/2011 N. Cardoso & P. Bicudo Programação em Paralelo: CUDA 1 / 12 CUDA Parte 3 N. Cardoso & P. Bicudo Programação em

Leia mais

Programação em Paralelo. N. Cardoso & P. Bicudo. Física Computacional - MEFT 2010/2011

Programação em Paralelo. N. Cardoso & P. Bicudo. Física Computacional - MEFT 2010/2011 Programação em Paralelo CUDA N. Cardoso & P. Bicudo Física Computacional - MEFT 2010/2011 N. Cardoso & P. Bicudo Programação em Paralelo: CUDA 1 / 11 CUDA Parte 2 N. Cardoso & P. Bicudo Programação em

Leia mais

Programação em Paralelo. N. Cardoso & P. Bicudo. Física Computacional - MEFT 2012/2013

Programação em Paralelo. N. Cardoso & P. Bicudo. Física Computacional - MEFT 2012/2013 Programação em Paralelo CUDA N. Cardoso & P. Bicudo Física Computacional - MEFT 2012/2013 N. Cardoso & P. Bicudo Programação em Paralelo: CUDA 1 / 19 CUDA "Compute Unified Device Architecture" Parte 1

Leia mais

Programação em Paralelo. N. Cardoso & P. Bicudo. Física Computacional - MEFT 2012/2013

Programação em Paralelo. N. Cardoso & P. Bicudo. Física Computacional - MEFT 2012/2013 Programação em Paralelo CUDA N. Cardoso & P. Bicudo Física Computacional - MEFT 2012/2013 N. Cardoso & P. Bicudo Programação em Paralelo: CUDA 1 / 23 CUDA "Compute Unified Device Architecture" Parte 2

Leia mais

CPU - Significado CPU. Central Processing Unit. Unidade Central de Processamento

CPU - Significado CPU. Central Processing Unit. Unidade Central de Processamento CPU - Significado CPU Central Processing Unit Unidade Central de Processamento CPU - Função Na CPU são executadas as instruções Instrução: comando que define integralmente uma operação a ser executada

Leia mais

Computação Heterogênea Programação paralela, clusters e GPUs

Computação Heterogênea Programação paralela, clusters e GPUs Computação Heterogênea Programação paralela, clusters e GPUs Profa. Dra. Denise Stringhini (ICT- Unifesp) Primeiro Encontro do Khronos Chapters Brasil Belo Horizonte, 20/09/2013 Conteúdo Computação heterogênea:

Leia mais

Análise de complexidade

Análise de complexidade Introdução Algoritmo: sequência de instruções necessárias para a resolução de um problema bem formulado (passíveis de implementação em computador) Estratégia: especificar (definir propriedades) arquitectura

Leia mais

Organização de Computadores 2005/2006 Processamento Paralelo

Organização de Computadores 2005/2006 Processamento Paralelo Organização de Computadores 2005/2006 Processamento Paralelo Paulo Ferreira paf a dei.isep.ipp.pt Maio de 2006 Introdução 2 Porquê?...........................................................................................

Leia mais

Unidade de Controlo. Unidade Aritmética e Lógica

Unidade de Controlo. Unidade Aritmética e Lógica Métodos de Programação I Departamento de Matemática, FCTUC 8 Modelo de Organização de um Computador Digital - Modelo de Von Neumann Neste modelo esquemático de organização de um computador digital tradicional

Leia mais

Capítulo 4. MARIE (Machine Architecture Really Intuitive and Easy)

Capítulo 4. MARIE (Machine Architecture Really Intuitive and Easy) Capítulo 4 João Lourenço Joao.Lourenco@di.fct.unl.pt Faculdade de Ciências e Tecnologia Universidade Nova de Lisboa 2007-2008 MARIE (Machine Architecture Really Intuitive and Easy) Adaptado dos transparentes

Leia mais

Aplicação Informática para o Ensino de Processamento Digital de Imagem

Aplicação Informática para o Ensino de Processamento Digital de Imagem Aplicação Informática para o Ensino de Processamento Digital de Imagem Sandra Jardim * e Paulo Sequeira Gonçalves ** * Departamento de Engenharia Informática e Tecnologias da Informação ** Departamento

Leia mais

O Problema do Fractal de Mandelbrot como Comparativo de Arquiteturas de Memória Compartilhada GPU vs OpenMP

O Problema do Fractal de Mandelbrot como Comparativo de Arquiteturas de Memória Compartilhada GPU vs OpenMP O Problema do Fractal de Mandelbrot como Comparativo de Arquiteturas de Memória Compartilhada GPU vs OpenMP Bruno P. dos Santos, Dany S. Dominguez, Esbel V. Orellana Departamento de Ciências Exatas e Tecnológicas

Leia mais

Vídeo Vigilância Abordagem Open-Source

Vídeo Vigilância Abordagem Open-Source Vídeo Vigilância Abordagem Open-Source Alunos: Justino Santos, Paulo Neto E-mail: eic10428@student.estg.ipleiria.pt, eic10438@student.estg.ipleiria.pt Orientadores: Prof. Filipe Neves, Prof. Paulo Costa

Leia mais

Processamento de Alto Desempenho utilizando Unidade de Processamento Gráfico - GPU

Processamento de Alto Desempenho utilizando Unidade de Processamento Gráfico - GPU Processamento de Alto Desempenho utilizando Unidade de Processamento Gráfico - GPU Francisco Ribacionka e Ettore Enrico (STI ) USP/STI/InterNuvem internuvem@usp.br Março -2016 Processamento de Alto Desempenho

Leia mais

Waldemar Celes. 25 de Agosto de 2014

Waldemar Celes. 25 de Agosto de 2014 Introdução a CUDA INF2062 Tópicos em Simulação e Visualização Waldemar Celes celes@inf.puc-rio.br Tecgraf, DI/PUC-Rio 25 de Agosto de 2014 W. Celes Introdução a CUDA 1 GPGPU Programação de propósito geral

Leia mais

Sistemas Operativos I

Sistemas Operativos I Gestão da Memória Luis Lino Ferreira / Maria João Viamonte Fevereiro de 2006 Gestão da Memória Gestão de memória? Porquê? Atribuição de instruções e dados à memória Endereços lógicos e físicos Overlays

Leia mais

Introdução aos Computadores

Introdução aos Computadores Os Computadores revolucionaram as formas de processamento de Informação pela sua capacidade de tratar grandes quantidades de dados em curto espaço de tempo. Nos anos 60-80 os computadores eram máquinas

Leia mais

Manual do GesFiliais

Manual do GesFiliais Manual do GesFiliais Introdução... 3 Arquitectura e Interligação dos elementos do sistema... 4 Configuração do GesPOS Back-Office... 7 Utilização do GesFiliais... 12 Outros modos de utilização do GesFiliais...

Leia mais

Introdução aos Sistemas Operativos

Introdução aos Sistemas Operativos Introdução aos Sistemas Operativos Computadores e Redes de Comunicação Mestrado em Gestão de Informação, FEUP 06/07 Sérgio Sobral Nunes mail: sergio.nunes@fe.up.pt web: www.fe.up.pt/~ssn Sumário Definição

Leia mais

Sistema de Computação

Sistema de Computação Sistema de Computação Máquinas multinível Nível 0 verdadeiro hardware da máquina, executando os programas em linguagem de máquina de nível 1 (portas lógicas); Nível 1 Composto por registrados e pela ALU

Leia mais

Gestor de Processos Núcleo do Sistema Operativo. Sistemas Operativos 2012 / 2013. Gestor de Processos

Gestor de Processos Núcleo do Sistema Operativo. Sistemas Operativos 2012 / 2013. Gestor de Processos Gestor de Processos Núcleo do Sistema Operativo Sistemas Operativos 2012 / 2013 Gestor de Processos Entidade do núcleo responsável por suportar a execução dos processos Gestão das Interrupções Multiplexagem

Leia mais

Entradas/Saídas. Programação por espera activa Programação por interrupções

Entradas/Saídas. Programação por espera activa Programação por interrupções Entradas/Saídas Programação por espera activa Programação por interrupções Programação por espera activa 1. O programa lê o estado do periférico: CPU pede ao controlador (IN) o valor no registo ESTADO

Leia mais

Introdução ao Processador CELL BE

Introdução ao Processador CELL BE 1 Introdução ao Processador CELL BE por: José Ricardo de Oliveira Damico 17 / Maio / 2007 São Paulo SP 2 SUMÁRIO LISTA DE FIGURAS 3 RESUMO 4 1.) INTRODUÇÃO 5 1.1) O que é? 5 2.) Utilização 5 3.) FUNCIONAMENTO

Leia mais

Estrutura e funcionamento de um sistema informático

Estrutura e funcionamento de um sistema informático Estrutura e funcionamento de um sistema informático 2006/2007 Sumário A constituição de um sistema informático: hardware e software. A placa principal. O processador, o barramento e a base digital. Ficha

Leia mais

Capítulo 8. Software de Sistema

Capítulo 8. Software de Sistema Capítulo 8 Software de Sistema Adaptado dos transparentes das autoras do livro The Essentials of Computer Organization and Architecture Objectivos Conhecer o ciclo de desenvolvimento da linguagem Java

Leia mais

Aula 10 - Streams (Parte I)

Aula 10 - Streams (Parte I) Disciplina de TICs 1 - Introdução a Programação em GPGPU Aula 10 - Streams (Parte I) Introdução Até então foi visto como engenho de processamento paralelo massivo de dados nas GPUs pode aumentar assombrosamente

Leia mais

Universidade da Beira Interior Cursos: Matemática /Informática e Ensino da Informática

Universidade da Beira Interior Cursos: Matemática /Informática e Ensino da Informática Folha 1-1 Introdução à Linguagem de Programação JAVA 1 Usando o editor do ambiente de desenvolvimento JBUILDER pretende-se construir e executar o programa abaixo. class Primeiro { public static void main(string[]

Leia mais

Kernel Linux. Trabalho Realizador Por: Tiago Conceição Nº 11903. Representação artística do núcleo Linux

Kernel Linux. Trabalho Realizador Por: Tiago Conceição Nº 11903. Representação artística do núcleo Linux Kernel Linux Representação artística do núcleo Linux Trabalho Realizador Por: Tiago Conceição Nº 11903 Índice Introdução...2 O que é o Kernel...3 Como surgiu...4 Para que serve...5 Versões...6 Versões

Leia mais

Manual do Utilizador

Manual do Utilizador Faculdade de Ciências e Tecnologia da Universidade de Coimbra Departamento de Engenharia Electrotécnica e Computadores Software de Localização GSM para o modem Siemens MC35i Manual do Utilizador Índice

Leia mais

Placa de vídeo em CUDA

Placa de vídeo em CUDA Placa de vídeo em CUDA Matheus Costa Leone de Souza Krystian Aparacido Resumo Quando você tem um cálculo que possa ser grande demais para você realizar a mão, a primeira solução que lhe vem a cabeça é

Leia mais

Programação Paralela e Distribuída 2009/10. Fundamentos

Programação Paralela e Distribuída 2009/10. Fundamentos Programação Paralela e Distribuída 1 Porquê Programação Paralela? Se um único computador (processador) consegue resolver um problema em N segundos, podem N computadores (processadores) resolver o mesmo

Leia mais

GUIA DE FUNCIONAMENTO DA UNIDADE CURRICULAR

GUIA DE FUNCIONAMENTO DA UNIDADE CURRICULAR Curso Engenharia Informática Ano letivo 2012-2013 Unidade Curricular Arquitectura de Computadores ECTS 6 Regime Obrigatório Ano 2º Semestre 2ºsem Horas de trabalho globais Docente (s) Luis Figueiredo Total

Leia mais

6 - Gerência de Dispositivos

6 - Gerência de Dispositivos 1 6 - Gerência de Dispositivos 6.1 Introdução A gerência de dispositivos de entrada/saída é uma das principais e mais complexas funções do sistema operacional. Sua implementação é estruturada através de

Leia mais

Keeper of Knowledge. Capítulo 1 Conceitos Básicos do Java

Keeper of Knowledge. Capítulo 1 Conceitos Básicos do Java Capítulo 1 Conceitos Básicos do Java INTRODUÇÃO O objectivo deste tutorial é ensinar as regras básicas de programação em Java e facilitar a aprendizagem dos capítulos que se seguem. Qualquer dúvida sobre

Leia mais

Grupo I [4v] b. [0,6v] De que forma é que o escalonador do Linux tenta minimizar o impacto desta limitação?

Grupo I [4v] b. [0,6v] De que forma é que o escalonador do Linux tenta minimizar o impacto desta limitação? Número: Nome: LEIC/LERC 2011/12-2º Exame de Sistemas Operativos 3/Fevereiro/2012 Responda no enunciado, apenas no espaço fornecido. Identifique todas as folhas. Duração: 2h30m Grupo I [4v] 1. [0,6v] A

Leia mais

Arquitetura e Organização de Computadores. Capítulo 0 - Introdução

Arquitetura e Organização de Computadores. Capítulo 0 - Introdução Arquitetura e Organização de Computadores Capítulo 0 - Introdução POR QUE ESTUDAR ARQUITETURA DE COMPUTADORES? 2 https://www.cis.upenn.edu/~milom/cis501-fall12/ Entender para onde os computadores estão

Leia mais

Gestor de Processos Núcleo do Sistema Operativo. Sistemas Operativos 2011 / 2012. Gestor de Processos

Gestor de Processos Núcleo do Sistema Operativo. Sistemas Operativos 2011 / 2012. Gestor de Processos Gestor de Processos Núcleo do Sistema Operativo Sistemas Operativos 2011 / 2012 Gestor de Processos Entidade do núcleo responsável por suportar a execução dos processos Gestão das Interrupções Multiplexagem

Leia mais

Identificação de Caracteres com Rede Neuronal Artificial com Interface Gráfica

Identificação de Caracteres com Rede Neuronal Artificial com Interface Gráfica Identificação de Caracteres com Rede Neuronal Artificial com Interface Gráfica João Paulo Teixeira*, José Batista*, Anildio Toca**, João Gonçalves**, e Filipe Pereira** * Departamento de Electrotecnia

Leia mais

Capítulo 8 Arquitetura de Computadores Paralelos

Capítulo 8 Arquitetura de Computadores Paralelos Capítulo 8 Arquitetura de Computadores Paralelos Necessidade de máquinas com alta capacidade de computação Aumento do clock => alta dissipação de calor Velocidade limitada dos circuitos => velocidade da

Leia mais

Programação Paralela Híbrida em CPU e GPU: Uma Alternativa na Busca por Desempenho

Programação Paralela Híbrida em CPU e GPU: Uma Alternativa na Busca por Desempenho 124 - Encontro Anual de Tecnologia da Informação Programação Paralela Híbrida em CPU e GPU: Uma Alternativa na Busca por Desempenho André Luís Stefanello¹, Crístian Cleder Machado1, Dioni da Rosa¹, Maurício

Leia mais

CPU Unidade Central de Processamento. História e progresso

CPU Unidade Central de Processamento. História e progresso CPU Unidade Central de Processamento História e progresso O microprocessador, ou CPU, como é mais conhecido, é o cérebro do computador e é ele que executa todos os cálculos e processamentos necessários,

Leia mais

Edison Gustavo Muenz. Estudo e implementação de um algoritmo de processamento de imagens com técnicas GPGPU

Edison Gustavo Muenz. Estudo e implementação de um algoritmo de processamento de imagens com técnicas GPGPU Edison Gustavo Muenz Estudo e implementação de um algoritmo de processamento de imagens com técnicas GPGPU Florianópolis SC Agosto / 2008 Edison Gustavo Muenz Estudo e implementação de um algoritmo de

Leia mais

Curso Técnico de Informática de Sistemas

Curso Técnico de Informática de Sistemas Curso Técnico de Informática de Sistemas Módulo: 772 Sistemas Operativos Formador: Henrique Fidalgo Objectivos da UFCD: Instalar e configurar sistemas operativos. Instalar e configurar utilitários sobre

Leia mais

Aspectos de Sistemas Operativos

Aspectos de Sistemas Operativos Paulo Sérgio Almeida Grupo de Sistemas Distribuídos Departamento de Informática Universidade do Minho Serviços de um sistema operativo Interface com o utilizador Chamadas ao sistema Programas de sistema

Leia mais

1 Padrões de Implementação em Processamento de Imagens. 2 Resumo. 4 Computação paralela. 1.1 Relátório final para PIBIC/CNPq

1 Padrões de Implementação em Processamento de Imagens. 2 Resumo. 4 Computação paralela. 1.1 Relátório final para PIBIC/CNPq 1 Padrões de Implementação em Processamento de Imagens 1.1 Relátório final para PIBIC/CNPq Victor M. de A. Oliveira, Rubens Campos Machado Centro de Tecnologia da Informação Renato Archer CTI Divisão de

Leia mais

Auditoria de senhas em hardware paralelo com o John the Ripper O impacto das tecnologias de processamento paralelo na quebra de senhas

Auditoria de senhas em hardware paralelo com o John the Ripper O impacto das tecnologias de processamento paralelo na quebra de senhas Auditoria de senhas em hardware paralelo com o John the Ripper O impacto das tecnologias de processamento paralelo na quebra de senhas Claudio André claudio.andre@correios.net.br Motivação Seu computador

Leia mais

PROJETO LÓGICO DE COMPUTADORES Prof. Ricardo Rodrigues Barcelar http://www.ricardobarcelar.com.br

PROJETO LÓGICO DE COMPUTADORES Prof. Ricardo Rodrigues Barcelar http://www.ricardobarcelar.com.br - Aula 6 - ARQUITETURAS AVANÇADAS DE COMPUTADORES 1. INTRODUÇÃO As arquiteturas dos processadores têm evoluído ao longo dos anos, e junto com ela o conceito de arquitetura avançada tem se modificado. Nos

Leia mais

Gestão de Configurações II

Gestão de Configurações II Gestão de Configurações II Bibliografia Livro: Software Configuration Management Patterns: Effective Teamwork, Practical Integration Gestão de Projecto 14 Padrões de Gestão Os padrões de gestão de configurações

Leia mais

Programação Engenharia Informática (11543) 1º ano, 1º semestre Tecnologias e Sistemas de Informação (6619) 1º ano, 1º semestre

Programação Engenharia Informática (11543) 1º ano, 1º semestre Tecnologias e Sistemas de Informação (6619) 1º ano, 1º semestre Programação Engenharia Informática (11543) 1º ano, 1º semestre Tecnologias e Sistemas de Informação (6619) 1º ano, 1º semestre Cap. 01 Fundamentos de Computadores Sumário : Conceitos básicos: computador,

Leia mais

3.1. Paralelização em CUDA (GPU-PGLIQ)

3.1. Paralelização em CUDA (GPU-PGLIQ) 44 3 3.1. Paralelização em CUDA (GPU-PGLIQ) Aplicação: Aceleração Base No algoritmo serial de PGLIQ, o maior tempo de processamento está na avaliação da função de aptidão, embora este procedimento seja

Leia mais

Sistemas Operacionais Universidade Federal de Santa Catarina. Sistemas Operativos para Celulares Symbian OS

Sistemas Operacionais Universidade Federal de Santa Catarina. Sistemas Operativos para Celulares Symbian OS Sistemas Operacionais Universidade Federal de Santa Catarina Sistemas Operativos para Celulares Symbian OS Autores Carlos Jorge Lemos Nunes Fábio Rafael Magalhães Malheiro Introdução Num mundo cada vez

Leia mais

É a associação de mais de um fluxo de execução em um único processo.

É a associação de mais de um fluxo de execução em um único processo. Profa. Rita Rodorigo Threads Um processo é uma abstração que reúne uma série de atributos como espaço de endereçamento descritores de arquivos abertos, quotas, etc. Um processo possui ainda uma área de

Leia mais

Máquinas virtuais. Máquina virtual de um processo. Máquinas virtuais (3) Máquina virtual de sistema. Máquinas virtuais (1) VMware para Windows e Linux

Máquinas virtuais. Máquina virtual de um processo. Máquinas virtuais (3) Máquina virtual de sistema. Máquinas virtuais (1) VMware para Windows e Linux System API Máquinas virtuais System ISA (Instruction Set Architecture) Aplicações Chamadas ao sistema Sistema de Operação Hardware User ISA (Instruction Set Architecture) Uma máquina virtual executa software

Leia mais

SiDEI. Sistema de Avaliação Automática de Alunos. Gestão e Desenvolvimento de Aplicações Informáticas

SiDEI. Sistema de Avaliação Automática de Alunos. Gestão e Desenvolvimento de Aplicações Informáticas SiDEI Sistema de Avaliação Automática de Alunos Gestão e Desenvolvimento de Aplicações Informáticas Disciplina de Engenharia de Software Instituto Superior de Engenharia do Porto Alunos: André Serafim

Leia mais

LICENCIATURA EM COMPUTAÇÃO PROCESSADOR TEGRA 2

LICENCIATURA EM COMPUTAÇÃO PROCESSADOR TEGRA 2 LICENCIATURA EM COMPUTAÇÃO PROCESSADOR TEGRA 2 SANTO AMARO 2011 ANGELO RAMOS JACKELINE BARBOSA JEANDERVAL SANTOS PROCESSADOR TEGRA 2 Trabalho apresentado ao Instituto Federal de Ciências e Tecnologia da

Leia mais

Conjunto de Instruções e Arquitectura p.1

Conjunto de Instruções e Arquitectura p.1 Conjunto de Instruções e Arquitectura Luís Nogueira luis@dei.isep.ipp.pt Departamento Engenharia Informática Instituto Superior de Engenharia do Porto Conjunto de Instruções e Arquitectura p.1 Organização

Leia mais

DEPARTAMENTO DE ENGENHARIA INFORMÁTICA FACULDADE DE CIÊNCIAS E TECNOLOGIA DA UNIVERSIDADE DE COIMBRA

DEPARTAMENTO DE ENGENHARIA INFORMÁTICA FACULDADE DE CIÊNCIAS E TECNOLOGIA DA UNIVERSIDADE DE COIMBRA DEPARTAMENTO DE ENGENHARIA INFORMÁTICA FACULDADE DE CIÊNCIAS E TECNOLOGIA DA UNIVERSIDADE DE COIMBRA Sistemas Operativos 2003/2004 Trabalho Prático #2 -- Programação em C com ponteiros -- Objectivos Familiarização

Leia mais

Desempenho de Computadores

Desempenho de Computadores Desempenho de Computadores João Canas Ferreira Arquitectura de Computadores FEUP/LEIC Contém figuras de Computer Organization and Design, D. Patterson & J. Hennessey, 3ª. ed., MKP Tópicos Os vários aspectos

Leia mais

Base de dados I. Base de dados II

Base de dados I. Base de dados II Base de dados I O que é? Uma base de dados é um simples repositório de informação, relacionada com um determinado assunto ou finalidade, armazenada em computador em forma de ficheiros Para que serve? Serve

Leia mais

CAD Trabalho III. PThreads e OpenMP. Pedro Carvalho de Oliveira Rui André Ponte Costa

CAD Trabalho III. PThreads e OpenMP. Pedro Carvalho de Oliveira Rui André Ponte Costa Universidade de Coimbra Faculdade de Ciências e Tecnologia Departamento de Engenharia Informática CAD Trabalho III PThreads e OpenMP Pedro Carvalho de Oliveira Rui André Ponte Costa Maio 2008 Resumo Neste

Leia mais

Porque as suas regras de negócio são específicas, precisa de uma sua solução de gestão que permite gerir essa diferença.

Porque as suas regras de negócio são específicas, precisa de uma sua solução de gestão que permite gerir essa diferença. Porquê NEXT Vision Porque as suas regras de negócio são específicas, precisa de uma sua solução de gestão que permite gerir essa diferença.... Poder de adaptação Porque cabe a si decidir como pretende

Leia mais

Gestor de Processos. Gestor de Processos

Gestor de Processos. Gestor de Processos Gestor de Processos Núcleo do Sistema Operativo Gestor de Processos Entidade do núcleo responsável por suportar a execução dos processos Gestão das Interrupções Multiplexagem do Processador Despacho efectua

Leia mais

CONCEITOS BÁSICOS DE UM SISTEMA OPERATIVO

CONCEITOS BÁSICOS DE UM SISTEMA OPERATIVO 4 CONCEITOS BÁSICOS DE UM SISTEMA OPERATIVO CONCEITOS BÁSICOS MS-DOS MICROSOFT DISK OPERATION SYSTEM INSTALAÇÃO E CONFIGURAÇÃO DE UM SISTEMA OPERATIVO LIGAÇÕES À INTERNET O que é um sistema operativo?

Leia mais

1 Geral... 3. 2 Utilizador... 7

1 Geral... 3. 2 Utilizador... 7 FAQ Tema: FAQ Índice de conteúdos 1 Geral... 3 1.1 O que é a COMPUTAEX?...3 1.2 O que é o CénitS?...3 1.3 O que é o LUSITÂNIA?...3 1.4 Quais os objectivos que se pretendem atingir desde a Fundação COMPUTAEX?...3

Leia mais

MEMÓRIA M.1 - HIERARQUIA DE MEMÓRIAS NUM COMPUTADOR DIGITAL

MEMÓRIA M.1 - HIERARQUIA DE MEMÓRIAS NUM COMPUTADOR DIGITAL MEMÓRIA M.1 - HIERARQUIA DE MEMÓRIAS NUM COMPUTADOR DIGITAL Quando se caminha no sentido da memória secundária encontramos memórias com maior capacidade, maior tempo de acesso e mais baixo custo/bit. Fig

Leia mais

SOFTWARE. A parte lógica do Computador. Escola Superior de Tecnologia e Gestão Instituto Politécnico de Bragança Novembro de 2006

SOFTWARE. A parte lógica do Computador. Escola Superior de Tecnologia e Gestão Instituto Politécnico de Bragança Novembro de 2006 Introdução à Informática SOFTWARE A parte lógica do Computador Escola Superior de Tecnologia e Gestão Instituto Politécnico de Bragança Novembro de 2006 Conceito de Software Parte lógica do sistema de

Leia mais

Módulo 4: Processos. Conceito de Processo. Escalonamento de processos Operações sobre processos Processos cooperantes Comunicação entre processos

Módulo 4: Processos. Conceito de Processo. Escalonamento de processos Operações sobre processos Processos cooperantes Comunicação entre processos Módulo 4: Processos Conceito de Processo Escalonamento de processos Operações sobre processos Processos cooperantes Comunicação entre processos 4.1 Conceito de Processo Um Sistema Operacional executa uma

Leia mais

Bases de Dados II Engª. Informática + Ensino Informática

Bases de Dados II Engª. Informática + Ensino Informática Introdução SQL SERVER hugomcp@di-ubi.pt, 2004 Arranque do MS SQLServer UNIVERSIDADE DA BEIRA INTERIOR Departamento de Informática Bases de Dados II Engª. Informática + Ensino Informática Pode-se usar o

Leia mais

Simplifique a complexidade do sistema

Simplifique a complexidade do sistema 1 2 Simplifique a complexidade do sistema Com o novo controlador de alto desempenho CompactRIO Rodrigo Schneiater Engenheiro de Vendas National Instruments Leonardo Lemes Engenheiro de Sistemas National

Leia mais

Ferramentas Web, Web 2.0 e Software Livre em EVT

Ferramentas Web, Web 2.0 e Software Livre em EVT E s t u d o s o b r e a i n t e g r a ç ã o d e f e r r a m e n t a s d i g i t a i s n o c u r r í c u l o da d i s c i p l i n a d e E d u c a ç ã o V i s u a l e T e c n o l ó g i c a AnimatorDV M a

Leia mais

LUIS HENRIQUE ALVES LOURENÇO PROCESSAMENTO PARALELO DE ÁUDIO EM GPU

LUIS HENRIQUE ALVES LOURENÇO PROCESSAMENTO PARALELO DE ÁUDIO EM GPU LUIS HENRIQUE ALVES LOURENÇO PROCESSAMENTO PARALELO DE ÁUDIO EM GPU CURITIBA 2009 LUIS HENRIQUE ALVES LOURENÇO PROCESSAMENTO PARALELO DE ÁUDIO EM GPU Trabalho de Conclusão de Curso apresentado como requisito

Leia mais

Notas da Aula 4 - Fundamentos de Sistemas Operacionais

Notas da Aula 4 - Fundamentos de Sistemas Operacionais Notas da Aula 4 - Fundamentos de Sistemas Operacionais 1. Threads Threads são linhas de execução dentro de um processo. Quando um processo é criado, ele tem uma única linha de execução, ou thread. Esta

Leia mais

Experimentos com a memória cache do CPU

Experimentos com a memória cache do CPU Experimentos com a memória cache do CPU Alberto Bueno Júnior & Andre Henrique Serafim Casimiro Setembro de 2010 1 Contents 1 Introdução 3 2 Desvendando o cache 3 2.1 Para que serve o cache?.....................

Leia mais

Conceitos básicos sobre TIC

Conceitos básicos sobre TIC Conceitos básicos sobre TIC Origem da palavra Informática Informação + Automática Informática Significado: Tratamento ou processamento da informação utilizando meios automáticos, nomeadamente o computador.

Leia mais

COMPUTAÇÃO PARALELA. uma visão geral. Guilherme Galante. v.2.0

COMPUTAÇÃO PARALELA. uma visão geral. Guilherme Galante. v.2.0 COMPUTAÇÃO PARALELA uma visão geral Guilherme Galante v.2.0 Guilherme Galante Bacharel em Informática Unioeste (2003) Mestre em Ciência da Computação UFRGS (2006) Professor Assistente do curso de Informática/Ciência

Leia mais

Programação Paralela em Ambientes Computacionais Heterogêneos com OpenCL

Programação Paralela em Ambientes Computacionais Heterogêneos com OpenCL Programação Paralela em Ambientes Computacionais Heterogêneos com OpenCL César L. B. Silveira Prof. Dr. Luiz G. da Silveira Jr. Prof. Dr. Gerson Geraldo H. Cavalheiro 28 de outubro de 2010 contato@v3d.com.br

Leia mais

Programação em Memória Compartilhada com OpenMP

Programação em Memória Compartilhada com OpenMP Programação em Memória Compartilhada com OpenMP Esbel Tomás Valero Orellana Bacharelado em Ciência da Computação Departamento de Ciências Exatas e Tecnológicas Universidade Estadual de Santa Cruz evalero@uesc.br

Leia mais

Instituto Superior de Engenharia do Porto Administração de Sistemas Informáticos I Clusters

Instituto Superior de Engenharia do Porto Administração de Sistemas Informáticos I Clusters Instituto Superior de Engenharia do Porto Administração de Sistemas Informáticos I Clusters Trabalho elaborado por: 980368 - Sérgio Gonçalves Lima 1010949 - Nisha Sudhirkumar Chaganlal Clusters O que é

Leia mais

Enunciado de apresentação do projecto

Enunciado de apresentação do projecto Engenharia de Software Sistemas Distribuídos 2 o Semestre de 2009/2010 Enunciado de apresentação do projecto FEARSe Índice 1 Introdução... 2 2 Cenário de Enquadramento... 2 2.1 Requisitos funcionais...

Leia mais

MATRIZ DE EXAME DE EQUIVALÊNCIA À FREQUÊNCIA

MATRIZ DE EXAME DE EQUIVALÊNCIA À FREQUÊNCIA DISCIPLINA: BASES DE PROGRAMAÇÃO CÓDIGO - 104 PASCAL Utilizar as instruções básicas da linguagem Pascal; Aplicar estruturas de decisão na elaboração de programas; Desenvolver programas em Pascal de forma

Leia mais

Entradas/Saídas. 1. Princípios de hardware/software de E/S 2. Camadas de software de E/S 3. Relógios (Temporizadores) 4. Gestão de consumo de potência

Entradas/Saídas. 1. Princípios de hardware/software de E/S 2. Camadas de software de E/S 3. Relógios (Temporizadores) 4. Gestão de consumo de potência Entradas/Saídas 1. Princípios de hardware/software de E/S 2. Camadas de software de E/S 3. Relógios (Temporizadores) 4. Gestão de consumo de potência Organização de um Sistema Operativo System Call Handler

Leia mais

Sistema de Visão Computacional sobre Processadores com Arquitetura Multi Núcleos

Sistema de Visão Computacional sobre Processadores com Arquitetura Multi Núcleos Roberto Kenji Hiramatsu Sistema de Visão Computacional sobre Processadores com Arquitetura Multi Núcleos Tese apresentada à Escola Politécnica da Universidade de São Paulo para obtenção do Título de Doutor

Leia mais

Comparativo de desempenho do Pervasive PSQL v11

Comparativo de desempenho do Pervasive PSQL v11 Comparativo de desempenho do Pervasive PSQL v11 Um artigo Pervasive PSQL Setembro de 2010 Conteúdo Resumo executivo... 3 O impacto das novas arquiteturas de hardware nos aplicativos... 3 O projeto do Pervasive

Leia mais

M323 AUTOMAÇÃO TRABALHO LABORATORIAL Nº 7

M323 AUTOMAÇÃO TRABALHO LABORATORIAL Nº 7 ESCOLA SUPERIOR NÁUTICA INFANTE D. HENRIQUE DEPARTAMENTO DE ENGENHARIA MARÍTIMA M323 AUTOMAÇÃO TRABALHO LABORATORIAL Nº 7 INTRODUÇÃO À PROGRAMAÇÃO DE AUTÓMATOS INDUSTRIAIS Por: Prof. Luis Filipe Baptista

Leia mais

Introduçã o ão MATLAB e Octave

Introduçã o ão MATLAB e Octave Introduçã o ão MATLAB e Octave O MATLAB é o software mais usado em engenharia para computação numérica. Foi desenhado como um programa interativo especialmente optimizado para calcular operações numéricas

Leia mais

JOSÉ HENRIQUE MADEIRA CIMINO ANÁLISE DE PARALELISMO EM ARQUITETURA MULTICORE COM USO DE UNIDADE DE PROCESSAMENTO GRÁFICO

JOSÉ HENRIQUE MADEIRA CIMINO ANÁLISE DE PARALELISMO EM ARQUITETURA MULTICORE COM USO DE UNIDADE DE PROCESSAMENTO GRÁFICO 1 FUNDAÇÃO DE ENSINO EURÍPIDES SOARES DA ROCHA CENTRO UNIVERSITÁRIO EURÍPIDES DE MARÍLIA UNIVEM CURSO DE CIÊNCIA DA COMPUTAÇÃO JOSÉ HENRIQUE MADEIRA CIMINO ANÁLISE DE PARALELISMO EM ARQUITETURA MULTICORE

Leia mais

Sistemas Operacionais

Sistemas Operacionais Sistemas Operacionais Sistemas de Entrada/Saída Princípios de Hardware Sistema de Entrada/Saída Visão Geral Princípios de Hardware Dispositivos de E/S Estrutura Típica do Barramento de um PC Interrupções

Leia mais

Universidade Federal do ABC. Dissertação de Mestrado. Aderbal de Morais Junior

Universidade Federal do ABC. Dissertação de Mestrado. Aderbal de Morais Junior Universidade Federal do ABC Curso de Pós Graduação em Ciência da Computação Dissertação de Mestrado Aderbal de Morais Junior UMA BIBLIOTECA PARA DESENVOLVIMENTO DE APLICAÇÕES CUDA EM AGLOMERADOS DE GPUS

Leia mais

1.3. Componentes dum sistema informático HARDWARE SOFTWARE

1.3. Componentes dum sistema informático HARDWARE SOFTWARE 1.3. Componentes dum sistema informático Computador Sistema Informático HARDWARE SOFTWARE + Periféricos Sistema Operativo Aplicações HARDWARE - representa todos os componentes físicos de um sistema informático,

Leia mais

CPU Fundamentos de Arquitetura de Computadores. Prof. Pedro Neto

CPU Fundamentos de Arquitetura de Computadores. Prof. Pedro Neto Fundamentos de Arquitetura de Computadores Prof. Pedro Neto Aracaju Sergipe - 2011 Conteúdo 4. i. Introdução ii. O Trabalho de um Processador iii. Barramentos iv. Clock Interno e Externo v. Bits do Processador

Leia mais

Sistemas Operativos I

Sistemas Operativos I Componentes de um Sistema Operativo Maria João Viamonte / Luis Lino Ferreira Fevereiro de 2006 Sistema Operativo Um Sistema Operativo pode ser visto como um programa de grande complexidade, responsável

Leia mais

O hardware é a parte física do computador, como o processador, memória, placamãe, entre outras. Figura 2.1 Sistema Computacional Hardware

O hardware é a parte física do computador, como o processador, memória, placamãe, entre outras. Figura 2.1 Sistema Computacional Hardware 1 2 Revisão de Hardware 2.1 Hardware O hardware é a parte física do computador, como o processador, memória, placamãe, entre outras. Figura 2.1 Sistema Computacional Hardware 2.1.1 Processador O Processador

Leia mais

Sistemas Operativos. Princípios de sistemas operativos. Rui Maranhão (rma@fe.up.pt)

Sistemas Operativos. Princípios de sistemas operativos. Rui Maranhão (rma@fe.up.pt) Sistemas Operativos Princípios de sistemas operativos Rui Maranhão (rma@fe.up.pt) Agenda objectivos de um computador objectivos de um sistema operativo evolução dos sistemas operativos tipos de sistemas

Leia mais

EIC. Projecto I. Manual do Utilizador. Vídeo Vigilância Abordagem Open Source. Curso: Engenharia de Informática e Comunicações Ano Lectivo: 2005/2006

EIC. Projecto I. Manual do Utilizador. Vídeo Vigilância Abordagem Open Source. Curso: Engenharia de Informática e Comunicações Ano Lectivo: 2005/2006 EIC Engenharia de Informática e Comunicações Morro do Lena, Alto Vieiro Apart. 4163 2401 951 Leiria Tel.: +351 244 820 300 Fax.: +351 244 820 310 E-mail: estg@estg.iplei.pt http://www.estg.iplei.pt Engenharia

Leia mais

Arquitetura e Organização de Computadores. Capítulo 0 - Introdução

Arquitetura e Organização de Computadores. Capítulo 0 - Introdução Arquitetura e Organização de Computadores Capítulo 0 - Introdução POR QUE ESTUDAR ARQUITETURA DE COMPUTADORES? 2 https://www.cis.upenn.edu/~milom/cis501-fall12/ Entender para onde os computadores estão

Leia mais

.Net Remoting Pizzaria

.Net Remoting Pizzaria .Net Remoting Pizzaria 1º Trabalho Prático Tecnologias de Distribuição e Integração 4º Ano do Mestrado Integrado em Engenharia Informática e Computação João Carlos Figueiredo Rodrigues Prudêncio ei07111@fe.up.pt

Leia mais

Processos e Threads (partes I e II)

Processos e Threads (partes I e II) Processos e Threads (partes I e II) 1) O que é um processo? É qualquer aplicação executada no processador. Exe: Bloco de notas, ler um dado de um disco, mostrar um texto na tela. Um processo é um programa

Leia mais