O projeto propõe o estudo e a aplicação de técnicas e ferramentas de paralelização automática no desenvolvimento de uma ferramenta de compilação e de um ambiente de execução. A ferramente de compilação irá detectar regiões paralelizáveis que possam ter sua execução acelerada e o ambiente de execução irá tratar do escalonamento de tarefas de múltiplas aplicações, explorando a integração entre multicore e multiGPU em um modelo de paralelização que trabalhe tanto com paralelismo de distribuição de computação, quanto cooperação entre os elementos de processamento na resolução de problemas. No cenário atual é evidente a grande distância entre o potencial de desempenho disponibilizado pelas plataformas modernas e as aplicações que precisam fazer uso desse potencial. De um lado temos plataformas multicore que integram arranjos de coprocessadores e GPUs com grande poder de processamento, e do outro aplicações científicas com código legado que continuam sendo utilizadas e servindo aos propósitos para os quais foram criadas. Um dos principais desafios para essas plataformas modernas é a coexistência com outras plataformas, com outras tecnologias já consolidadas e com suas respectivas linguagens de desenvolvimento amplamente utilizadas.
Programar novas aplicações ou traduzir aplicações de código legado para estas novas plataformas não é uma tarefa trivial. Os kits de desenvolvimento, ainda não estão maduros o suficiente para serem acessíveis de maneira amigável a todas as classes de usuários. Os kits fornecem aos desenvolvedores bibliotecas do ambiente de execução (runtime) e dos drivers que abstraem o acesso aos recursos do hardware até certo nível. Quanto a forma de geração de código em grande parte dos trabalhos relacionados, as ferramentas consideram código escrito na linguagem C ou Fortran, e a partir dele geram a versão do código paralela com o apoio dos compiladores disponibilizados pelos fabricantes ou com outras ferramentas com backends que geram o código final para GPU. No caso da abordagem de diretivas de compilação a ideia seguida é a de anotar o código com diretivas (\#pragma) que na fase de preprocessamento são tratadas e é feita a inserção de definições e macros no código que no processo de ligação com o ambiente de execução são substituídas pelo código que fará o chaveamento entre dispositivos.
Na abordagem de paralelização automática o que é diferente é que o código não precisa ser anotado, as regiões candidatas à paralelização são detectadas automaticamente e da mesma forma código para a ligação com o ambiente de execução é inserido no código final. Estudos preliminares mostram que as ferramentas existentes e abordagens conhecidas até o momento, não exploram efetivamente todos os recursos disponíveis nessas plataformas. Não fazem uso eficiente dos recursos ou geram código sem a preocupação com essa questão.
Consideram na geração de código apenas uma das classes de dispositivos, gerando código para uma única CPU ou GPU. Se a opção for gerar código para GPU utilizam a que for especificada pelo usuário ou por padrão escolhem a que tem o maior número de núcleos. De forma análoga, quando o alvo são CPUs ignoram a existência de multicore, gerando código para ser executado em uma única thread, não aproveitando os múltiplos núcleos. Em ambos os casos, não consideram a existência de múltiplos elementos de processamento e nem a combinação deles em uma solução híbrida. Esse comportamento evidencia o uso não eficiente de recursos, que são subutilizados ou desprezados na geração de código e em sua execução, e reforça a ideia de que existe a necessidade de um ambiente de execução que explore cenários heterogêneos, com o uso misto de elementos de processamento multicore e multiGPU, o que abre espaço para o desenvolvimento desta proposta.