Detail

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

In contrast with previous processor generations, expected upcoming machines comprise kilo-core heterogeneous parallel devices that will usher a radical change in the way that software is developed and maintained. parallel programming must be embraced to leverage the full power of these devices without foregoing portability at the code and performance levels. Currently code is CPU-specific which makes it more difficult to use heterogeneous systems. Power-conscious computations are also expected to become more important.
Current mainstream parallel programming languages mix, at source code level, domain-specific issues with to efficient execution on specific platforms, leading to: (1) difficulty to adapt the application to
different platforms and/or running conditions, (2) low levels of reuse across platforms, (3) invasive approaches to parallelise code and (4) lack of independent development.
We propose to address the aforementioned issues by developing methodologies and tools to promote a better separation of concerns. We aim to specify applications in a high-level, platform-independent manner 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.

The project expects to 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.