General-purpose Aspect-Oriented framework for heterogeneous multicore Parallel systems



In the next years it is expected to see a sustained increase on the number of cores on every desktop machine and the integration of heterogeneous processing elements (e.g., GPU) into these multicore devices. In contrast with previous processor generations, these kilo-core heterogeneous parallel devices will require a radical change in the way that software is develop and maintained. Thus, to leverage the full power of these devices portable parallel programming must be embraced to specify parallel tasks. Portability should be attained at code and performance level. Currently code is specific for a CPU or for a GPU which increases development time and makes it more difficult to use all available processing elements. Moreover, power-conscious computations will gain stronger importance.

Current mainstream parallel programming languages mix, at source code level, domain-specific issues and issues related to efficient execution on specific platforms (e.g., MPI, OpenMP and CUDA). This leads to: (1) difficulty to adapt the application to different platforms and/or running conditions, (2) low code reuse across platforms, (3) an invasive approach to parallelise code, and (4) no independent development. For instance, it is hard to change the parallelisation strategy independently of the domain-specific code. Generally, to adapt the application to different target platforms and/or running conditions, if not the whole application at least a significant part of it must be redesigned and/or rewritten.

We propose to address these issues by developing methodologies and tools to promote a better separation of concerns (i.e., by separating domain specific from platform specific concerns). The idea is to specify applications in a high-level platform independent manner in order to (dynamically) map them into specific platforms/processing elements and/or running conditions through additional application modules (e.g., parallelisation/platform specific concerns). These additional concerns are provided in latter development stages and can also benefit from programmers knowledge of the application domain required to generate (efficient) platform-specific implementations.

Portability and code reuse across platforms can be achieved by implementing mappings through multiple pluggable features (i.e., fine-grained modules) to include only features required for each target (e.g., CPU, GPU and FPGA). This also allows us to change mappings during execution by supporting pluggable features at runtime. This approach encapsulates variability across platforms/runtime into well defined, (un)pluggable, modules. Each module can be specified by its own set of abstractions (e.g., using a data-flow model for data dependencies). One of these modules could implement a data partition strategy to scatter data across processor memories, making it possible to change and compose data partitions (e.g., to optimise data placement for multiple levels of memory). Other module could specify coordination of multiple control flows (e.g., a barrier). Aspect-oriented programming provides an effective and efficient way to implement these (un)pluggable mechanisms as aspects can be considered program transformations that map programs into new programs.

Project Goals

Key research issues in this project include:

  • Development of a high-level, declarative and platform-independent style of programming, that promotes a better separation of domain-specific issues from those parallelisation/platform specific.
  • Definition of a set of contracts between domain-specific code and parallelisation/platform specific code that improve support for independent development.
  • Development of mappings of high-level programming abstractions for multiple targets (e.g., CPU, GPU, FPGA).
  • Definition of strategies to select the most appropriate target platform/processing elements for a given set of applications characteristics and to dynamically change the target platform (either due to application load changes or power requirements). This includes dynamic changes to the amount of resources allocated to the application and the use of heterogeneous processing elements.
  • Exploitation of aspect-oriented techniques to explicitly parallelise code in order to take advantage of heterogeneous parallel systems.

Overall, the project will deliver a new framework that will make it easier to develop applications for heterogeneous parallel systems. Applications will be specified in a high-level platform independent manner and the framework dynamically maps applications into available resources, according to applications characteristics and load/power requirements.

The framework will be validated through a large-scale application: the Java Evolutionary Computation Library (JECoLi), a computational platform that implements the main algorithms in Evolutionary Computation and related metaheuristics, namely Evolutionary Algorithms, Differential Evolution, Simulated Annealing or Particle Swarms. This application will be updated to efficiently run on heterogeneous parallel systems using the proposed framework.


This work was funded by ERDF – European Regional Development Fund through the COMPETE Programme (operational programme for competitiveness) and by National Funds through the FCT – Fundação para a Ciência e a Tecnologia (Portuguese Foundation for Science and Technology) within project FCOMP-01-0124-FEDER-010152.

Project funding: COMPETE; QREN; EU-FEDER; FCT


  • João Luís Sobral (CCTC-UM)
  • Rui Mendes (CCTC-UM)
  • Miguel Pessoa Monteiro (CITI-UNL)
  • Miguel Rocha (CCTC-UM)
  • António Joaquim Esteves (CCTC-UM)
  • Diogo Telmo Neves (CCTC-UM)
  • Rui Carlos Gonçalves (CCTC-UM)
  • João Barbosa (CCTC-UM)
  • Bruno Medeiros (CCTC-UM)


[bibtex key=Pinho:2010,Medeiros:2011a,Medeiros:2011,Silva:2011,Medeiros:2012,Goncalves:2012,Medeiros:2013b,Batory:2013,Medeiros:2013,Pinho:2013,Faria:2013,Goncalves:2014b,Goncalves:2014,Medeiros:2015a,Goncalves:2015a,Goncalves:2015]