Emilio Francesquini

On the energy efficiency and performance of irregular application executions on multicore, NUMA and manycore platforms

Until the last decade, performance of HPC architectures has been almost exclusively quantified by their processing power. However, energy efficiency is being recently considered as important as raw performance and has become a critical aspect to the development of scalable systems. These strict energy constraints guided the development of a new class of so-called light-weight manycore processors. This study evaluates the computing and energy performance of two well-known irregular NP-hard problems-the Traveling-Salesman Problem (TSP) and K-Means clustering-and a numerical seismic wave propagation simulation kernel-Ondes3D-on multicore, NUMA, and manycore platforms. First, we concentrate on the nontrivial task of adapting these applications to a manycore, specifically the novel MPPA-256 manycore processor. Then, we analyze their performance and energy consumption on those different machines. Our results show that applications able to fully use the resources of a manycore can have better performance and may consume from 3.8 i? to 13 i? less energy when compared to low-power and general-purpose multicore processors, respectively. Programming for a manycore is challenging.Limited memory and NoC are among the most important constraints of manycores.For CPU-bound and mixed workloads, MPPA-256 achieves better performance than Xeon.MPPA-256 consumes up to 13 i? less energy than embedded and general-purpose multicores.

Analysis of computing and energy performance of multicore, NUMA, and manycore platforms for an irregular application

The exponential growth in processor performance seems to have reached a turning point. Nowadays, energy efficiency is as important as performance and has become a critical aspect to the development of scalable systems. These strict energy constraints paved the way for the development of multi and manycore processors. Research on the performance and the energy efficiency of numerical kernels on multicores are common but studies in the context of manycores are sparse. Unlike these works, in this paper we analyze a well-known irregular NP-complete problem, the Traveling-Salesman Problem (TSP). This study investigates two aspects of the TSP on multicore, NUMA, and manycore processors. First, we concentrate on the nontrivial task of adapting this application to a manycore, specifically the novel MPPA-256 manycore processor. Then, we analyze its performance and energy consumption on different platforms that comprise general-purpose and low-power multicores, a NUMA machine, and the MPPA-256 manycore. Our results show that applications able to fully use the resources of a manycore can have better performance and may consume 9.8 and 13 times less energy when compared to low-power and general-purpose multicore processors, respectively.

Energy Efficient Seismic Wave Propagation Simulation on a Low-Power Manycore Processor

Large-scale simulation of seismic wave propagation is an active research topic. Its high demand for processing power makes it a good match for High Performance Computing (HPC). Although we have observed a steady increase on the processing capabilities of HPC platforms, their energy efficiency is still lacking behind. In this paper, we analyze the use of a low-power manycore processor, the MPPA-256, for seismic wave propagation simulations. First we look at its peculiar characteristics such as limited amount of on-chip memory and describe the intricate solution we brought forth to deal with this processors idiosyncrasies. Next, we compare the performance and energy efficiency of seismic wave propagation on MPPA-256 to other commonplace platforms such as general-purpose processors and a GPU. Finally, we wrap up with the conclusion that, even if MPPA-256 presents an increased software development complexity, it can indeed be used as an energy efficient alternative to current HPC platforms, resulting in up to 71% and 81% less energy than a GPU and a general-purpose processor, respectively.

A middleware for reflective web service choreographies on the cloud

Web service composition is a commonly used solution to build distributed systems on the cloud. Choreographies are one specific kind of service composition in which the responsibilities for the execution of the system are shared by its service components without a central point of coordination. Due to the distributed nature of these systems, a manual approach to resource usage monitoring and allocation to maintain the expected Quality of Service (QoS) is not only inefficient but also does not scale. In this paper, we present an open source choreography enactment middleware that is capable of automatically deploying and executing a composition. Additionally, it also monitors the composition execution to perform automatic resource provisioning and dynamic service reconfiguration based on pre-defined Service Level Agreement (SLA) constraints. To achieve that, it keeps a meta-level representation of the compositions, which contains their specifications, deployment statuses, and QoS attributes. Application developers can write specific rules that take into account these meta-data to reason about the performance of the composition and change its behavior. Our middleware was evaluated on Amazon EC2 and our results demonstrate that, with little effort from the choreography developer or deployer, the middleware is able to maintain the established SLA using both horizontal and vertical scaling when faced with varying levels of load. Additionally, it also reduces operational costs by using as little computational resources as possible.

Actor scheduling for multicore hierarchical memory platforms

Erlang applications are present in several mission-critical systems. These systems demand substantial computing resources that are usually provided by multiprocessor and multi-core platforms. Hierarchical memory platforms, or Non-Uniform Memory Access (NUMA) architectures, account for an important share of these platforms. Yet, the research on the suitability of the current virtual machine (VM) for these platforms is quite limited. The current VM assumes a flat memory space, thus not performing as well as it could on these architectures. The NUMA environment presents challenges to the runtime environment in fields varying from memory management to scheduling and load-balancing. In this article we summarize some of the characteristics of an actor based application to, in light of the above, introduce some NUMA-aware improvements to the Erlang VM. This modified VM uses the NUMA characteristics and the application knowledge to take better memory management, scheduling and load-balancing decisions. We show that, when we consider the default Erlang VM as the baseline, the modified VM can achieve performance improvements up to a factor of 2.50 while limiting the slowdown on the worst case by a factor of 1.15.

CHOReOS: scaling choreographies for the internet of the future

The Internet has been growing at a impressive rate in many aspects such as size, heterogeneity, and usage. This growth forces the continuous improvement of Internet infrastructure technologies. The Future Internet concept magnifies the required shift for Internet technologies, which shall allow supporting the continuously growing scale of the converging networking world together with new generations of services made available to and brought by the broad mass of end users. The CHOReOS project positions itself in this vision of the Future Internet, whilst focusing on the Future Internet of Services. This research project aims at assisting the engineering of software service compositions in this novel networking environment by devising a dynamic development process, and associated methods, tools and middleware, to sustain the composition of services in the form of large-scale choreographies for the Internet of the future.

A NUMA-Aware Runtime Environment for the Actor Model

The actor model is present in several mission-critical systems, such as those supporting WhatsApp and Twitter. These systems serve thousands of clients simultaneously, therefore demanding substantial computing resources usually provided by multiprocessor and multicore platforms. Non-Uniform Memory Access (NUMA) architectures account for an important share of these platforms. Yet, little or no research has been done on the suitability of the current actor runtime environments for these machines. Current runtime environments assume a flat memory space, thus not performing as well as they could. The NUMA environment presents challenges to the actor model runtime environment in fields varying from memory management to scheduling and load-balancing. In this document we analyze and characterize actor based applications to, in light of the above, propose improvements to actor runtime environments. As a proof of concept, we have applied our ideas in a real actor runtime environment, the Erlang virtual machine. This modified virtual machine uses the NUMA characteristics and the application knowledge to take better memory management, scheduling and load-balancing decisions. We have evaluated this modified runtime environment using standard benchmarks and, taking the default virtual machine as a baseline, we improved the performance of the tested applications by a factor of 2.50 on the best case while limiting our slowdown on the worst case by a factor of 1.09.

Towards an Enactment Engine for Dynamically Reconfigurable and Scalable Choreographies

Service compositions have recently been in the spotlight. Although they are not something new, as the complexity of service based systems grows, we observe an ever increasing interest in these approaches. Choreographies are one specific kind of service composition in which the responsibilities for the execution of the system are shared by its service components without any central point of coordination. Choreography clients expect a minimum level of Quality of Services (QoS), however, due to the distributed nature of these systems, a manual approach to resource usage monitoring and allocation is not only inefficient but also does not scale. In this paper we present an open source choreography enactment engine that is capable of automatically deploying and executing a given composition. Additionally, it also monitors a composition execution to perform automatic resource provisioning and dynamic service reconfiguration based on pre-defined Service Level Agreements (SLA) constraints. We evaluated our system on Amazon EC2 and preliminary results demonstrate that it is able maintain the QoS of a composition, even when faced with varying levels of load, while at the same time reducing costs by using as little computational resources as possible.

Improving the performance of actor model runtime environments on multicore and manycore platforms

The actor model is present in many systems that demand substantial computing resources which are often provided by multicore and multiprocessor platforms such as non-uniform memory access architectures (NUMA) and manycore processors. Yet, no mainstream actor model runtime environment (RE) currently in use takes into account the hierarchical memory characteristics of these platforms. These REs essentially assume a flat-memory space therefore not performing as well as they could. In this paper we present our proposal to improve the performance of these systems. Using knowledge about the general characteristics of actor-based applications and the underlying platform, we propose techniques spanning from memory management to scheduling and load-balancing. Based on previous work, we present our design guidelines for the RE adaptation to the Kalray MPPA-256 manycore processor.

HybridVerifier: A Cross-Platform Verification Framework for Instruction Set Simulators

Instruction set simulators (ISSs) play a critical role in the design cycle of embedded systems. However, as ISSs evolve and increase in complexity, not only new bugs might be introduced but also old latent bugs might be revealed. Finding these bugs based on the simulator output might be a challenging task. This letter presents HybridVerifier, a novel and retargetable framework for ISS verification. It relies on hybrid simulation between the ISS and the host processor (x86), using the host’s memory as a reference for the simulated architecture. We demonstrate the effectiveness of our approach in three different scenarios: 1) ISS model verification; 2) processor specific libraries/functionalities; and 3) cross compiler bugs.