Colocação Automática de Computação em Hardware Heterogêneo

Exportado OPUSMade available in DSpace on 2019-08-11T07:51:44Z (GMT). No. of bitstreams: 1 keziacorrea.pdf: 1577885 bytes, checksum: e2325905745406f19123e865ecb882a0 (MD5) Previous issue date: 24As placas de processamento gráfico (GPUs) revolucionaram a programação de alto desempenho, pois elas reduziram o custo do hardware paralelo. A programação desses dispositivos, contudo, é um desafio, pois programadores ainda não são treinados para escrever código que coordene a atuação simultânea de milhares de threads. A fim de lidar com esse problema, a indústria e a academia vem introduzindo sistemas de anotações, como OpenMP 4.0, OpenSs e OpenACC, que permitem indicar quais partes de um programa C ou Fortran deveriam executar em GPU ou em CPU. Essa abordagem possui duas vantagens. Primeiro, ela mantém programadores em sua zona de conforto: eles podem continuar desenvolvendo código em sua linguagem de programação preferida. Segundo, as anotações protegem programadores de minúcias do hardware paralelo, uma vez que elas passam a tarefa de paralelizar programas para o gerador de código. Apesar de a inserção de diretivas no código esconder detalhes de hardware, ela não resolve todos os problemas do programador: ele ainda precisa identificar quando será vantajoso executar um dado trecho de código na GPU e quando não. Nesse contexto, o objetivo desta dissertação é apresentar uma solução para tal problema. Foram projetadas, implementadas e testadas técnicas para identificar de forma automática quais porções do código devem executar na GPU. Para isso foram utilizadas informações de dependência, layout de memória, intensidade aritmética e fluxo de controle. Foram criadas um conjunto de análises estáticas de código que realizam três tarefas: (i) identificar quais laços são paralelizáveis; (ii) inserir anotações para copiar dados entre a CPU e a GPU; (iii) estimar quais laços, uma vez marcados como paralelos, possuem maior probabilidade de levar a ganhos de desempenho. Essas tarefas são realizadas sem qualquer intervenção do usuário. A plataforma que ora é apresentada foi implementada sobre dois compiladores. As análises foram feitas sobre a infra-estrutura de compilação disponível em LLVM. A geração de código paralelo a partir de programas anotados é feita por PGCC. A abordagem desenvolvida, até o presente momento, é totalmente estática: é decidido onde cada função deve executar durante a compilação do programa, e tal decisão não muda durante a sua execução. Outro benefício deste arcabouço é que ele é completamente automático, ou seja, não possui nenhuma intervenção do programador(a). Os programas produzidos - de forma totalmente automática - obtiveram speedups de até 121x.Graphics processing Units (GPUs) have revolutionized high performance programming.They reduced the cost of parallel hardware, however, programming these devices is still a challenge. Programmers are not able (yet) to write code to coordinate the simultaneousperformance of thousands of threads. To deal with this problem, the industry and the academia have introduced annotation systems. Examples of those systems are OpenMP 4.0, OpenSS and OpenACC, which allow developers to indicate which parts of a C or Fortran program should perform on GPU or CPU. This approach has two advantages. First, it lets programmers to obtain the benefits of the parallel hardwarewhile coding in their preferred programming languages. Second, the annotations protect programmers from details of the parallel hardware, once they pass the task of parallelizing programs for the code generator.The inclusion of pragmas in the code to hide details of the hardware does not solve all the problems that developers face when programming GPUs: they still need to identify when it will be advantageous to run a given piece of code on the GPU. In this context, the objective of this dissertation is to present a solution to such a problem. It was designed, implemented and tested techniques to automatically identify whichportions of the code must run on the GPU. For this, we used dependency information, memory layout and control flow. Were created a set of static analysis that performs three tasks: (i) identify which loops are parallelizable; (ii) insert annotations to copy data between the CPU and the GPU; (iii) estimate which loops, once tagged as parallels, are most likely to lead to performance gains. These tasks are totally automatic, are carried out without any user intervention. The platform that is presented has been implemented on two compilers. The analyses were built on top of the infrastructure available in LLVM. The parallel code generation, from annotated programs, is made by PGCC. The approach that we have developed is completely static: we decide where each function must run during the compilation of the program. This decision does not relyon any runtime system such as a middleware, or special computer architecture hooks. Another benefit of this framework is that it is completely automatic, i.e. it does not require any intervention from the programmer. As a result, programs that we produce automatically - can be up to 121x faster than their original versions