A multi-language and multi-platform framework for resource consumption analysis and its application to energy-efficient software development

Resumen

Reducing and controlling the energy consumption and the environmental impact of computing technologies have become a challenging problem worldwide. It is a significant issue in systems ranging from small Internet of Things devices to large data centers and high-performance computing systems. In spite of the recent rapid advances in energy-efficient hardware, it is software that controls the hardware, so that the greatest savings are expected from developing software applications that perform a better management of the energy-saving features provided by the hardware. For a given system, the potential for energy savings is likely to be much greater at the higher levels of abstraction in the system stack. Thus, promoting energy efficiency to a first class software design goal has become an important research challenge. This thesis addresses this challenge and provides tools and techniques for energy-aware software development. First, the thesis focuses on the development of techniques for the estimation of lower and upper bounds on the energy consumed by software applications, as well as the verification that such applications meet some energy budgets (given as specifications). Addressing a challenging objective, such techniques perform the estimations statically (i.e., at compile-time, without running the program with concrete data), and give such information in the form of functions on the input data sizes of programs. The proposed approach performs a combination of techniques for static program analysis with techniques for modeling the energy consumption of hardware platforms. One of the main contributions of the thesis is a multi-language general resource consumption analysis, based on a Horn clause transformation, and a specialization that infers both lower- and upper-bound energy functions at two levels, the Instruction Set Architecture (ISA) and the intermediate code (LLVM IR) levels, and reflects it upwards to the higher source code level. Another contribution is the experimental assessment of such analysis, which provides insights into the trade-off of precision versus analyzability at these levels, and concludes that the LLVM IR level analysis is a good compromise: it is reasonably powerfull and accurate (less than 6.4% average deviation vs. hardware measurements). The analysis estimates safe lower and upper bounds on the use of hardware- independent resources, such as execution steps. However, in order to infer safe bounds for hardware-dependent resources, such as energy, it needs to be fed with energy models that provide safe bounds too. To this end, the thesis proposes a novel modeling approach that consists in dividing a program into basic (branchless) blocks, establishing the maximal (resp. minimal) energy consumption for each block using an evolutionary algorithm. The approach has been tested on XC programs running on XMOS chips, but it is general enough to be applied to any microprocessor and programming language. Traditional static resource analyses estimate the total resource usage of a call to a program, without executing it. The thesis presents a novel resource analysis whose aim is instead the static profiling of accumulated cost, i.e., to discover, for selected parts of the program (named cost centers), bounds on the resource usage accumulated in each of those parts, which express how the total cost of a call to the main program is distributed among the different cost centers. This information is much more useful to the software developer than the standard (traditional) resource usage functions, as it allows identifying the parts of a program that should be optimized first, because of their greater impact on the total cost of program executions. Finally, the thesis explores some optimisations that can be performed by using the energy estimations provided by the aforementioned energy consumption analysis, and makes original contributions. In particular, the thesis proposes new methods based on evolutionary algorithms to improve energy-efficient task allocation and scheduling for DVFS-enabled multicore environments. For applications that allow certain levels of variability in the accuracy of their results, the thesis also proposes algorithms to exploit the trade-off between accuracy and energy consumption.