A framework for heterogeneous many-core machines

Abstract

Software development is known for being a complex task, especially when parallelism is involved. This complexity can, however, be reduced by dividing the software into smaller manageable modules. This philosophy is embraced by modular programming, which promotes the separation of concerns in well-defined modules. Unfortunately, traditional parallel programming models (e.g., OpenMP and MPI) are typically nonmodular, leading to the mix of parallelism- and domain- related concerns. To aim for maximum performance the parallel applications should be tuned to the characteristics of the target architecture(s). However, in traditional approaches, this tuning process leads to unceasing and invasive adjustments of the domain code since the parallelism-related concerns are mixed directly in the domain code. This lack of modularity increases the complexity of parallel programming and jeopardizes the application maintenance. These problems are even more exacerbated in hybrid parallelism (i.e., combining shared and distributed memory), which aims to exploit hierarchical systems such as clusters of multicore machines. Hence, these hybrid systems increase the complexity of the development of parallel applications even more, and consequently, emphasize the need for modular approaches. This thesis exploits the notion that modularity, pluggability (i.e., the ability to (un)plug modules without modifying the base code), and composability are key properties to make the process of developing parallel applications less complex. The first step towards achieving these properties is the separation of the parallelism-related concerns from the domain concerns and consequent encapsulation in proper modules. This thesis exploited the use of aspect-oriented programming (AOP) to achieve the separation of parallelism-related concerns and combined it with a methodology based on structured programming and design rules (i.e., designing the domain code accordingly). The result is an aspect-oriented framework that enables the development of modular parallel applications. This framework intrinsically supports the development of applications with hybrid parallelism by composing, in a non-invasive fashion, several parallelism-related modules with a given domain code. This framework shines by combining the efficiency and expressiveness of popular HPC parallel programming models with the modular features of aspect- and object- oriented (OO) design. As a result of studying AOP in the context of parallelism, we introduce the idea of parallelism layers, which combines the simplicity of well-known OO concepts (i.e., class extension and method overriding) with the flexibility of AOP. On the one hand, this combination enables the users of our framework to add parallelism to domain code, using familiar concepts analogous to class extension and method overriding but without the limitations of OO inheritance. On the other hand, programmers can exploit the advanced features of AOP, which, among others, are helpful to extend the functionality of the framework. Hence, parallelism layers provide a simple yet flexible approach for the development of parallel applications. Finally, to reduce the complexity of parallel programming even further, we enhanced the parallelism layers with a methodology and a workflow to parallelize applications – including hybrid parallelizations – in an incremental and structured manner. We evaluated the performance and programmability of our framework in comparison to other approaches by using a set of case studies and executing them in a cluster of multicores. We illustrated, using our framework and workflow, the entire process of developing efficient and modular parallelizations – from the sequential up to the hybrid version. Moreover, we show that our framework and workflow help to find more efficient parallelizations than the ones initially implemented. These results showed that parallelism layers are ideal for the quick prototyping and testing of di↵erent parallel strategies. The results show that the parallelizations developed with the framework had a performance comparable to the intrusive parallelizations and, at the same time, were less verbose. With our approach, all the hybrid versions were seamlessly implemented. These hybrids were always faster than the correspondent versions that only used MPI processes, which emphasizes the potentiality of hybrid parallelizations in clusters of multicores.

O desenvolvimento de software é conhecido por ser uma tarefa complexa, especialmente quando o software pretende suportar paralelismo. No entanto, esta complexidade pode ser reduzida através da divisão do software em módulos mais pequenos e fáceis de gerir. Esta filosofia é adotada pela programação modular, que promove a separação de facetas em módulos bem definidos. Infelizmente, os modelos tradicionais de programação paralela (e.g., OpenMP e MPI) não promovem o desenvolvimento de software modular, levando à mistura de facetas referentes ao paralelismo e ao domínio. Para tentar atingir o máximo de desempenho, as aplicações paralelas devem ser afinadas de acordo com as características da(s) arquitetura(s) alvo. No entanto, em abordagens tradicionais, este processo de afinamento leva a ajustes constantes e invasivos do código do domínio, uma vez que o paralelismo está diretamente misturado com este. Esta falta de modularidade aumenta a complexidade da programação paralela e dificulta a manutenção da aplicação. Estes problemas são ainda mais veementes em paralelismo híbrido (i.e., a combinação de memória partilhada com memória distribuída), que tem como objectivo explorar sistemas hierárquicos tais como clusters de maquinas multinucleo. Assim, estes sistemas híbridos aumentam, ainda mais, a complexidade do desenvolvimento de aplicações paralelas, e consequentemente, realçam a importância de abordagens modulares. Esta tese explora a ideia de que modularidade, plugabilidade (i.e., a capacidade de (des)conectar módulos sem modificar o código base), e composabilidade são propriedades fundamentais para que o processo de desenvolvimento de aplicações paralelas seja menos complexo. O primeiro passo para atingir estas propriedades é a separação da faceta referente ao paralelismo da faceta do domínio e o consequente encapsulamento de cada faceta em módulos apropriados. Esta tese explorou o uso de programação orientada aos aspectos (POA) para promover a separação de facetas referentes ao paralelismo e combinou-a com uma metodologia baseada em programação estruturada e regras de desenho (i.e., o desenho do código do domínio de forma apropriada). O resultado é uma framework orientada aos aspetos que permite o desenvolvimento de aplicações paralelas modulares. Esta framework suporta intrinsecamente o desenvolvimento de aplicações com paralelismo híbrido através da composição, de forma não invasiva, de vários módulos de paralelismo com um dado código do domínio. Esta framework sobressai por combinar a eficiência e expressividade dos modelos de programação paralelas populares em HPC com as propriedades modulares de programação orientada aos aspetos e orientada aos objetos (OO). O estudo realizado nesta tese do uso da POA no contexto do paralelismo conduziu à introdução da ideia de camadas de paralelismo, que combina a simplicidade de conceitos OO bem conhecidos (i.e., extensão de classes e reescrita de métodos) com a flexibilidade de POA. Por um lado, esta combinação permite aos utilizadores da framework adicionar paralelismo utilizando conceitos familiares, e análogos, à extensão de classes e reescrita de métodos, mas sem as limitações de herança OO. Por outro lado, os programadores podem tirar partido das funcionalidades avançadas de POA, que entre outras, são úteis para estender a funcionalidade da framework. Assim, camadas de paralelismo oferecem uma abordagem simples, mas flexível, para o desenvolvimento de aplicações paralelas. Finalmente, para reduzir ainda mais a complexidade de programação paralela, enriqueceu-se as camadas de paralelismo com uma metodologia e um fluxo de trabalho para paralelizar aplicações – incluindo paralelizações híbridas – de forma incremental e estruturada. O desempenho e programabilidade da framework foi avaliado comparando-a com outras abordagens, usando um conjunto de casos de estudo que foram executados num cluster de maquinas multinucleo. Mostrou-se usando a framework e fluxo de trabalho, o processo completo de desenvolvimento de paralelizações modulares e eficientes – da versão sequencial ate à híbrida. Para além disso, mostrou-se que a framework e fluxo de trabalho ajudaram a encontrar paralelizações mais rápidas do que aquelas desenvolvidas inicialmente. Estes resultados mostram que camadas de paralelismo são ideais para a rápida prototipagem e teste de diferentes estratégias de paralelização. Os resultados mostram que as paralelizações desenvolvidas com a framework obtiveram um desempenho comparável às paralelizações intrusivas, e ao mesmo tempo com menos verbosidade. Com a abordagem proposta todas as versões híbridas foram facilmente implementadas. Estas versões híbridas foram sempre mais rápidas do que as versões correspondentes que só utilizaram processos MPI, facto que realça a potencialidade das paralelizações híbridas em clusters de máquinas multinucleo.