Déaglán Connolly Bree

Interest in the energy consumption of software has grown with rising energy costs and greater environmental awareness. Many approaches to research in this area have been proposed, from the examination of hardware and compiler optimizations to platform specific software modifications. However, the impact of general software design on energy efficiency remains unclear. The goal of this research is to summarize the findings of studies that empirically examine the impact of design patterns, code smells, and refactorings (which we collectively describe as design elements) on energy consumption. Our secondary goal is to provide an overview of the impact of these aspects of software design on energy performance and discuss the current state of the art. We present a systematic literature review (SLR) of papers that examine the impact of the aforementioned design elements on energy consumption. We perform a search through four major databases, a manual search through publications of eight conferences and five journals from 2010 through 2023, in addition to snowballing. We extract relevant data from the literature and present an overview of each experiment's setup, the data reported, and results for each design element studied. Beginning with a set of 8684 papers, we select 24 that include studies of these design elements. Overall, they provide data on 22 design patterns, 17 code smells, and 31 refactorings. Many studies are preliminary in nature, and contradictory findings are frequent. We present three main findings: (i) a wide array of design patterns, code smells, and refactorings have been examined from an energy performance perspective; (ii) many of these studies are preliminary in nature and indicate the need for further research; (iii) there has been little growth recently in publications empirically examining these aspects of software design.

Software metrics are measurable characteristics of software. They are commonly used to quantify qualitative aspects of software like internal quality and complexity. Energy-aware developers and researchers alike would benefit from the discovery of a static metric that correlates well with energy performance, as static metrics can be calculated at compile time rather than requiring run-time energy profiling. However, no static metric has been found that is a reliable indicator of energy performance to date. This work proposes a novel approach that employs run-time profiles to appropriately weight compile-time metrics in an effort to more accurately predict the energy performance of the software at run-time. Preliminary investigations using data from previous works highlight the potential for mean weighted coupling between objects (CBO) to be an indicator of energy performance. A subsequent experiment was conducted with a small application which was automatically refactored to reduce CBO, and consequently mean weighted CBO. Results are in line with the finding that increasing mean weighted CBO reduces energy consumption.

Design patterns are applied frequently during software evolution in order to make the software more flexible and amenable to extension. One little-studied aspect of design patterns is their propensity to increase run-time energy consumption due to the indirection and additional structure they introduce. In this paper we study the impact of the Visitor pattern on energy efficiency. The Visitor pattern separates an algorithm from the objects it acts upon and improves maintainability by placing each algorithm within a single visitor class. This is at the cost of increased indirection due to the double dispatch required when the algorithm is invoked. We experimentally investigate the energy impact of varying the implementation of this pattern, and of removing the pattern entirely from software written in Java and C++. In our results we observe energy consumption reductions greater than 7% in a Java-based textbook example when the pattern is implemented using reflective dispatch, and reductions of over 10% when experimenting with an open source Java project, JavaParser. The complete removal of the pattern yields more complex results, with little impact in the textbook example but reductions of over 7% in the JavaParser study. To explore the generalisability of our findings, we subsequently apply the same transformations to the C++ based CppParser. Total pattern removal here sees energy consumption reductions of over 66% while the reflective dispatch approach increases energy consumption by up to 2012%. Our results highlight the energy savings that can be achieved when the Visitor pattern is removed both in Java and C++ implementations, and also show that some language specific features can allow for further energy savings when the implementation of the pattern is varied.