Aplicações Java em arquiteturas paralelas de acesso não uniforme à memória

Dissertação de mestardo em Engenharia InformáticaDurante várias décadas, o aumento do desempenho dos processadores era conseguido maioritariamente através do aumento da frequência de relógio. Contudo, aumentar o desempenho através do aumento da frequência tornou-se cada vez mais difícil conduzindo a problemas de consumo energético e dissipação de calor. Para resolver estes problemas, as arquiteturas mais recentes evoluíram num sentido de aumentar o número de processadores, e mais tarde, o número de núcleos. As arquiteturas de memória inicialmente adotadas, designadas arquiteturas de acesso uniforme à memória (UMA), apresentaram algumas limitações. Entre as arquiteturas UMA existentes, existe a arquitetura de multiprocessamento simétrico (SMP). Esta arquitetura possui múltiplos processadores que acedem à memória principal utilizando um barramento partilhado pelos processadores que conduziu a problemas de contenção no acesso à memória principal. As arquiteturas de acesso não uniforme à memória (NUMA) surgiram durante os anos 90 com múltiplos bancos de memória. No entanto, os programadores que queiram tirar total partido das vantagens desta arquitetura, terão que lidar com novos desafios ao nível da programação, ao nível da afinidade dos fios de execução e das alocações de memória. Esta dissertação mostra que a forma como os algoritmos memory-bound acedem a dados de memória principal numa arquitetura NUMA, pode ter impacto no seu desempenho. Um conjunto de testes foi utilizado para demonstrar em que medida várias técnicas de afinidade podem contribuir para aumentar o desempenho de aplicações Java e C em arquiteturas NUMA. Os testes realizados com recurso a diferentes abordagens tais como ferramentas do sistema operativo, opções da JVM, técnicas de programação e até variáveis de afinidade para os compiladores, foram usados para aumentar a desempenho de dois casos de estudo em arquiteturas NUMA. A utilização destas abordagens permitiram aumentar o desempenho com um ganho adicional de até 1.8 vezes para as implementações em Java, e de até 2.16 vezes para as versões em C das mesmas aplicações.During several decades, computers performance improvement was mostly achieved by increasing the clock frequency of the processor. However, increasing the clock frequency became technically harder due to problems of dissipation and energy consumption. To deal with this problems, computer architectures started to go in the direction of increasing the number of processors. The memory architectures initially adopted namely Uniform Memory Access (UMA), presented scalability limitations. The Symmetric Multiprocessing (SMP) has multiple processors (potentially multicore) that access main memory uniformly using a system bus shared among all processors. This led to contention when accessing main memory. The Non-Uniform Memory Access (NUMA) came up during the 90’s with multiple memory banks. In NUMA systems, the number of memory banks can increase with the number of processors also scaling the overall memory bandwidth. These and other characteristics become especially attractive to speedup a class of algorithms whose scalability is limited by main memory performance designated by memory-bound algorithms. However, programmers who want to take full advantage of this memory architecture have to deal with new challenges, namely thread and memory affinity. This dissertation shows that how memory-bound algorithms access memory inNUMA architectures can have a significant impact on performance. A set of tests were used to identify how different techniques and affinity strategies can help improving the performance of Java and C algorithms in NUMA architectures. The tests were performed using different approaches as operating system tools, JVM options, programming techniques or affinity variables for the compilers. These approaches allowed to increase the scalability of two case studies in a NUMA architecture giving an additional speedup for Java applications up to 1.8 times, and up to 2.16 times for C implementations