-Software energy efficiency has been shown to remarkably affect the energy consumption of IT platforms. Besides “performance” of the code in efficiently accomplishing a task, its “correctness” matters too. Software containing defects is likely to fail and the computational cost to complete an operation becomes much higher if the user encounters a failure. Both performancerelated energy efficiency of software and its defectiveness are impacted by the quality of the code. Exploiting the relation between code quality and energy/defectiveness attributes is the main idea behind this position paper. Starting from the authors' previous experience in this field, we define a method to first predict the applications of a software system more likely to impact energy consumption and with higher residual defectiveness, and then to exploit the prediction for optimally scheduling the effort for code sanitization - thus supporting, by quantitative figures, the quality assurance teams' decision-makers. Index Terms-Reliability allocation, effort allocation, test planning, quality assurance, static analysis, prediction, optimization
Energy consumption of IT systems is increasingly becoming a concern, especially for large infrastructure managers. Research on Green IT is developing at a rapid pace, spanning from fields centered on hardware device and architectural design, to software design and development, as well as to operations management and usage practices.
Software energy efficiency has been shown to remarkably
affect energy consumption of all the other infrastructural levels
[
Both performance-related efficiency of software and its
defectiveness are related to the quality of the code. Quality is a
yG. Carrozza was with CAST Software when this paper was prepared.
multi-facet attribute, including reliability, usability, portability,
security, performance, efficiency [
Optimize the allocation of the effort for code
improvement to each application, based on the prediction results.
Effort allocation models are a very useful practice for
quality assurance planning on quantitative bases,
especially in large systems [
In the following, we first present our experience on both energy efficiency measurement and software defects analysis (Section II), with preliminary results about correlation with ASA rule violations; then, the method is presented in Section III; a roadmap is in Section IV.
II. PAST EXPERIENCE AND PRELIMINARY RESULTS
Measurement (and, in our case, prediction) of energy
efficiency is as much important as underestimated. Previous
studies shown that 86% of ICT departments in UK do not
know their CO2 emissions and 80% of companies do not know
their electric bill [
ET OT = Eidle + ECP U + EDB + ENET = Pidle tex + u + DDB eDB + DNET eNET (1) in which:
Pidle is the power absorption of the CPU in the idle state and tex is the time in which the system is idle;
is the usage of the CPU, and can be written as: 1 R t2 U%(t)dt !(t) where: U% is the percentage usage f t1 of the CPU at time t, ! is a function denoting the application-dependent consumption pattern, which may depend on many factors (e.g., number of concurrent users, type of operations, type of application, state of the DB, etc.); f is the clock frequency of the CPU; t1 and t2 are the initial and final measurement time;
u is the power absorption function of the CPU per percent usage (it is approximated by a constant assuming the power grows linearly with usage); DDB is the amount of data (in number bytes) exchanged with the DB, while eDB is the energy consumed to exchange 1 byte with the DB; DNET is the amount of data (in number bytes) exchanged with the network, while eNET is the energy consumed to exchange 1 byte with the network.
In this expression, the factors , DDB and DNET are
intrinsic characteristics of the software application, while u,
eDB and eNET depend on the hardware infrastructure. The
sole estimation of the former parameters allows computing the
energy consumption of the software application. In previous
studies [
Resource usage by the application can be estimated by dynamic analysis, namely by means of profiling during testing. However, there would be three problems with this approach: i) the result would depend on the goodness of test cases, namely on their ability to well represent the operational usage; ii) the result does not provide direct hints about how it is possible to optimize the code for performance improvement; iii) the result of such an evaluation could be provided too late, as (operational) testing is done at the end of the lifecycle, whereas developers would like to benefit from the feedback earlier.
We therefore explore the performance indications that can be given by ASA on the source code. In fact, the adherence or violation to predefined programming rules and patterns is able to suggest possible performance issues. This, in turn, is likely to impact energy consumption, as software with higher performance is expected to be more energy-efficient. We are exploring if there is any relation between Automatic Static code Analysis (ASA) rules and the usage pattern factor , which is the most relevant contributor to ET OT . As preliminary result we are obtaining, we have observed that some ASA rules, defined by means of the CAST c tool, are highly correlated to the metric, as reported in Table I.
Based on this result, we are confident that the infringements in terms of code rule violations as obtained by ASA are potentially correlated with energy efficiency. This is going to be exploited for our method formulation.
The quality of software can be well assessed by ASA. In
our previous experience [
Since defects are detected at later stages (i.e, during testing
or even operation) compared to violations (detected soon
after coding), their treatment is much more expensive. Thus,
it makes sense to try anticipating the knowledge about the
presence of defects as earlier as possible. To this aim, we
are exploring any possible relationship between programming
rules violation and the presence of software defects. There
is indeed a reasonable expectation that ASA violations are
correlated to defects (as proven in some past papers [
Based on the preliminary results about correlation, we propose the following allocation method. The method includes two steps: i) a prediction step, in which we run machine learning algorithms to build predictive models able of spotting the most relevant applications and ASA rules, from both energy and defectiveness point of view; ii) an optimization step, in which we exploit the output of prediction to orient the fixing of ASA rule violations in terms of: which applications and which rules should be prioritized in the correction. The goal is to provide quality team leaders with a quantitative means to figure out how to sanitize the code to pursue welldefined objectives of energy efficiency, quality and cost.
Predict applications more likely containing defects and applications more prone to consume energy before the integration/system/acceptance testing starts; Predict which rules more likely suggest the presence of defects and which ones suggest inefficiency bottlenecks (besides the side feedback of identifying the most critical rules that programmers are keen on violating).
Retrieving data from ASA reports about a set of applications of a tested or an operational system. Tracking of defects found during testing and of energy consumption measurements1 should be available.
Training of prediction models. We mean to test several
different models, by varying both machine learning
algorithms (we opt for ranking algorithms, such as
regressionbased techniques [
Test of the models by 10-fold cross-validation, repeated
N = 30 times per each classifier (for statistical validity),
comparison and choice of the best model. Criteria for
comparison can be several (the most used ones are the
response variable value in the top 20% of samples and
Fault Percentile Average (FPA) [
Actual prediction on applications for which we know
only the ASA violations but anything about energy
consumption (and defects) yet. The output is a list of
applications rated by their expected energy consumption and
a list rated by expected defectiveness. The ranking-based
algorithms associate a ranking score with each sample in
the list. We call it pj (and qj , for energy consumption) and
normalize it in [
Rules rating. We analyze the impact of attribute
selection, by an attribute ranking algorithm such as the
Information Gain, which rates an attribute according
to the gain of information obtained by knowing that
attribute. The top rules useful for prediction are derived,
and each rule i is assigned a score si (hi for energy
consumption list) denoting the importance of that rule for
prediction. The scores are then normalized in [
Prediction information (!dj , di and !ej , ei ) is used to parametrize the optimization model. The steps we are going to implement for optimization are in the next Section.
Optimization of violation fixing is conceived to exploit the
above predictions to prioritize applications and rules to fix,
according to predefined objectives and constraints. We aim at
providing the team leader with sets of alternative solutions
for which the expected impact on cost, quality and energy
efficiency is known. Thus a multi-objective optimization
approach is formulated. The main objective of the proposed
approach can be stated as follows: suggest the number and type
of violations to remove and the applications from which they
should be removed in order to get the best tradeoffs among: i)
1See [
It would be extremely expensive to eliminate all violations of all types from all applications. The algorithm finds the best tradeoffs optimizing the objectives. Let us denote the decision variables xi;j , being the number of violations of the i-th type that the algorithm proposes to eliminate from application j. The three objectives are expressed as follows:
Min!
C = Max! Max!
Q =
E = C < C Q > Q E > E n
m XhX(xi;j Cfixi )
i j i=1 n m XhX(xi;j j i=1 n m XhX(xi;j j i=1 di ei i (Minimum Energy Reduction) subject to 0 xi;j
vi;j and to the following bounds: Further constraints on violations can be added, such as: n N1 X Pim=1(vi;j xi;j ) vmax, meaning that the residual j=1 number of average violations must be less than (or equal to) a target vmax. The first objective function minimizes the expected cost for violation removal. The second objective function assesses the expected quality increase (to maximize) as sum of violations xi;j to remove weighted by: the likelihood that violation of type i is actually correlated to defects, the likelihood that the interested application j is actually defectprone, and by the severity of the rule assigned by domain expert. Similarly, the third objective assesses the reduction of energy consumption (to maximize) if we remove xi;j violations. The solution provides a matrix with the amount of violations engineers should remove for each type and for each application, as well as the estimate of removal cost, the expected quality in terms of defects and the expected energy 2For instance, reliability rules might be assigned a higher defectivenessrelated severity; similarly, for performance rules in the energy case. (2) (3) consumption if sanitization actions are taken as suggested. Note that this is just an instance of multi-objective models that can be formulated, and that can give raise to numerous variants targeting specific needs. More generally, the core message is that we can setup code sanitization plans supported by quantitative reasoning, by exploiting prediction and considering quality and energy objectives together in the formulation.
As first step, we are going to validate the prediction and the
optimization steps separately. As for the prediction, we mean
to extend the set of test applications (across multiple domains)
to improve the generality of predictive models, and to extend
the set of metrics to improve their accuracy (e.g., with metrics
from version control systems [