The last decade has seen a significant paradigm shift in the way large-scale and embedded computing architectures are designed. Physical limits have recently been hit in single-core CPUs, paving the way to multi-core architectures. Energy requirements have given rise to the need for low-consumption processing units (e.g., those on board of mobile devices), while big-data applications are demanding for aggressive scale-up solutions (e.g., GPU-based and coprocessor-equipped architectures) able to process large chunks of data in parallel at an affordable power budget. Moreover, the recent commercial breakthrough of System-on-Chips (SoC) has paved the way to low-power computing systems embedding both (multicore) CPUs and GPUs. Any of these devices can be, and indeed are, combined together, either into a single-node machine, a low-power embedded system, or a cluster/grid. Overall, the current panorama offers a plethora of different computing systems and paradigms, which respond to varied needs and offer differentiated levels of energy consumption. However, these benefits come at a price: the complexity and the effort demanded from programmers and developers to exploit these new capabilities are significantly increased.
In order to exploit the energy and performance benefits coming from many-core systems without having to sacrifice programmability goals, we need to enact a paradigm shift similar in spirit to what hardware architectures have experienced in recent years, yet at the software level. Application developers must be supported by adequate operating system services, runtime environments, libraries and compilation toolchains to tame the complexity of nowadays architectures, while also aiming at increased efficiency.
To reach this goal, my research will involve transparency techniques spanning different software abstraction levels, and leveraging on a methodology which includes at least performance monitoring, program analysis and self-tuning schemes.
Given the current and foreseeable architectural trends, we cannot avoid thinking of hardware parallelism and heterogeneity as concepts pervasively affecting the daily-life operations of software applications. Many performance-critical factors of applications depend on the underlying environment they live in and the entire runtime software stack on top of which user applications sit must be considered a living part of modern software. Perhaps unsurprisingly, performance and energy aspects are commonly considered incompatible, while they can actually be optimized via joint efforts. For example, carefully mapping threads and data on cores and memory banks (as in NUMA scenarios) directly leads to reducing the machine cycles that are needed to access memory, hence the overall energy used. As another example, using hardware-based synchronization primitives (as for the case of HTM) in multi-thread applications can lead to making a more efficient use of hardware and firmware, thus producing benefits in terms of both performance and energy efficiency. As for the transparency requisite, it allows programmers to write applications according to familiar programming paradigms and models. Notably, this will enable both a reduction of the economic cost and time-to-market for developing software, and an increase in the dependability of applications. Additionally, it will allow for a cost-effective migration of existing programs. Therefore, since most of the work will be carried out transparently with respect to application code, the cost related to the actual exploitation of parallelism and heterogeneity will be significantly reduced.
For this reason, the innovation of my research can be found in the design of runtime software environments satisfying the following requisites:
- They must insulate the developer from low-level details of the hardware and from programming tasks that don¿t relate to the application¿s business logic;
- They must provide programmers with a robust API that endure time and that are flexible enough to satisfy differentiated needs, coming from different applications, over time;
- They must be lightweight and not be invasive in terms of the overhead for assisting the execution of the end application;
- They must virtualize the computing power of the underlying machine, so that applications can benefit from the full potential of heterogeneous architectures with no particular effort.