ArticlePDF Available

How to measure energy-efficiency of software: Metrics and measurement results

  • University of Applied Sciences Trier, Environmental Campus Birkenfeld
  • Leuphana University Lüneburg | Environmental Campus Birkenfeld

Abstract and Figures

In the field of information and computer technology (ICT), saving energy has its focus set on energy efficient hardware and its operation. Recently, efforts have also been made in the area of computer software. However, the development of energy efficient software requires metrics, which measure the software's energy consumption as well as models to monitor and minimize it. In software and software development processes they hardly exist. In this work we present a generic metric to measure software and a method to apply it in a software engineering process.
Content may be subject to copyright.
How to Measure Energy-Efficiency of Software: Metrics and Measurement Results
Timo Johann, Markus Dick, Stefan Naumann, Eva Kern
Trier University of Applied Sciences, Germany
(t.johann, m.dick, s.naumann, e.kern)
Abstract—In the field of information and computer tech-
nology (ICT), saving energy has its focus set on energy
efficient hardware and its operation. Recently, efforts have
also been made in the area of computer software. However,
the development of energy efficient software requires metrics,
which measure the software’s energy consumption as well as
models to monitor and minimize it. In software and software
development processes they hardly exist. In this work we
present a generic metric to measure software and a method to
apply it in a software engineering process.
Keywords-Energy Efficiency, Green Software, Metrics
Activities in the field of Green IT set new standards for the
requirements of information and communication technology.
Generally, these requirements primary concern the energy
consumption of ICT. The developments in Green IT, which
primarily focus on computer hardware, led to the under-
standing that “the most strategic aspect of energy efficient
computing will be the evolution of application software
to facilitate system-wide energy efficiency” [1, p.58]. This
paper presents a method to develop and apply metrics and
measurement methods to measure the energy consumption
that is directly related to the software. The method presented
here should enable software developers to continuously
measure and monitor the energy consumption of the software
during the development process. It seamlessly integrates into
the GREENSOFT Model (cf. figure. 1), a reference model for
Green and Sustainable Software [2].
Metrics for energy efficient software rely on its useful
work done [3]. Since, modern software consists of manifold
modules that all have a special purpose, there can be more
than just one metric. The software parts can be measured
individually or combined. For a proper comparison of soft-
ware the measured modules should be as similar as possible.
Basically a generic metric can be defined as
EnergyEff iciency =
There already exist approaches for measuring software en-
ergy consumption, mostly as black box measurement. White
box measurements, relying on source code instrumentation,
are hardly used. Figure 2 intends to classify the known
Figure 1. The Greensoft Model [2, p. 270]
methods of energy efficiency measurement. Benchmarking
methods are able to measure a system as a black box
and can generate a statement on how the entire system
(software and hardware) performs on the whole. When it
comes to measuring a given software, one cannot apply
these benchmarks because each of them is customized for
one specific group of tasks (database benchmarks, graphic
benchmarks, etc.). The approach of Dick et al. [4] defines
individual scenarios for a specific group of software (e.g.
Browsers) and then measures concrete occurrences with the
same scenario, which can give a better statement about the
software’s energy consumption. These approaches can be
categorized as black box measurements because they do not
allow to take a look inside, which is their main disadvantage.
That is why we propose a kind of white box measurement
to tell in which part of software there is potential for energy
savings. A white box method is better suited to find resource
intensive parts of programs and to improve them. To do so,
we will use a known technique: source code instrumentation,
which is often used in the context of software profiling, e.g.
for runtime analysis.
The experimental set-up to perform a white box
measurement consists of a set of components (cf. figure
3). The system under test runs an instrumented application
and is connected to a power meter. The power meter
is connected to the measuring system, where an Energy
2012 IEEE
GREENS 2012, Zurich, Switzerland
Figure 2. Methods to Measure Energy Efficiency
Server converts the values to performance counters. The
instrumented application also writes performance counters.
These can be read, e.g. by logging or monitoring tools
to analyze the software regarding its energy consumption.
To accomplish the instrumentation the set-up builds on
an API provided by Intel to perform the source code
instrumentation [3]. Using this set-up, existing source code
can be expanded by counters. These numerical values can
be used e.g. for counting loop cycles, marking entry and
exit points of code fragments, counting the amount of how
often parts of software are frequented, etc.
Figure 3. Measurement Environment
A. Sorting Application
Since sorting is a common task in computer science, and
is easy enough to quickly find the useful work, it is good
as a first example. Here it is obvious that the useful work is
sorting items and it follows that the metric is
make it a little bit more exciting we will use two different
implementations of sorting algorithms that basically differ
in their complexity. Thus, we have something to compare.
Therefore, we picked Bubble Sort with a complexity of
) and Heap Sort with a complexity of O ( n · log(n)).
The sorting application is implemented to generate an array
with n randomly generated double values. Then the array
should be sorted using Bubble Sort; make a break and remix
the array values, and then use Heap Sort to perform the same
task. For the instrumentation, we declared two counters; one
counter counts the items that are already sorted, the other
counter is used as a phase counter and is only meant to
generate a positive edge when sorting starts and a negative
edge when sorting ends. Bubble Sort uses double nested
for-loops. The outer loop goes over the array from 0 to
n once. Every time the loop reenters the counter increases
and an item is sorted. Counting the sorted items in Heap
Sort is similar. After transforming the array into a binary
heap, a for-loop goes over it and after every pass the counter
increases and an item is sorted.
Since the system performs several background processes and
services, which cause some peaks in the processor time (red)
and in the energy consumption (green), we measured the
average idle consumption which is about 65 Watt.
Then the actual measurement of the algorithms with
bubble sort is started, which is shown in figure 4. The
algorithms sort 200,000 double values. The phase counter
(blue) indicates the start of sorting, which instantly stresses
the CPU (red) and increases the consumed energy (green).
When all items are sorted (b lack), the phase counter gener-
ates the negative edge which is the end of the measurement.
The sorting time was 110 seconds and the average energy
consumption was 100 Watts.
100W 110s = 11000Ws =3Wh = 11000J
The whole algorithm consumed 10,800 Joule for the
sorting of 200,000 double values, which results in
200, 000
10, 800J
= 18
The Heap Sort algorithm also sorted 200,000 double
values and the result is shown in figure 4, where it is obvious
that the algorithm worked - as expected - much faster. The
values were sorted in five seconds. Due to the resolution
(1 second) the power consumption line (green) did not
immediately follow the phase counter, but here the average
power consumption during processing was 100 Watts, which
results in 100W 5s = 500Ws =0.14Wh = 500J.
For a better comparison it is rational to give the algorithms
the same time frame and calculate the power consumption
of the idle time of the faster algorithm and add it to the total
power consumption. Since the idle time is 110 5 = 105,
and the idle power consumption is 65, the power consump-
tion is 65W 105s = 6825Ws =1.89Wh = 6825J.
Adding the energy consumed during sorting the result is
7325 J.
200, 000
500J + 6825J
= 27.3
The algorithm with the better asymptotic run time seems
to also have the better energy efficiency, which corroborates
the assumption that an algorithm with a higher performance
also has a higher energy efficiency.
Figure 4. Energy Consumption of Heap Sort (Top) and Bubble Sort
B. Multi User Web Application
As a second example we chose a web-based information
system. Usually there are parts such as browser, web-server
and database involved. Therefore, we chose a client/server
application, which is used in productive operations at the
Environmental Campus Birkenfeld. Its purpose is to collect,
process and visualize consumption data of the campus
buildings (like: energy, water, etc). The server stores the
data in a database that is managed by a web interface. For
demonstration purposes only a cut-out of the software is
used. One of its capabilities is to visualize the consumption
data as a line graph over a time period. The charts are
dynamically generated for each request.
When looking at the description of the chart feature,
a useful metric is:
. This metric can be
expanded to other parts of the chart generation, e.g.
database queries, the image generation, and the complete
request/response cycle. We assume that this is a good way
to represent the energy consumption of this part of the
software. It must be kept in mind that there is no ’one size
fits all’ metric and applications can be split up into more
or less fine-grained modules, which have their own metrics.
The load for the measurement will be simulated and is
generated by a fixed number of users, which send multiple
requests to the server. Therefore, the source code must be
instrumented at the point where the request comes in and
where the response goes out. The counters must increase
with an incoming request and decrease when the response
is sent. Thus, we know how many requests are currently in
progress. In addition to the two systems described in the
Table I
User Count 15 Users 25 Users
7, 3
J oules
J oules
Response Time
0.5 seconds 0.8 seconds
set-up, one can use a third system that generates the load.
Here, we will try to demonstrate how the energy efficiency
changes when serving different amount of users.
In a first testrun a load of 15 users was generated.
The result is shown in figure 5. After the ramp-up period
the users that are waiting for their response (blue) even
out at approximately six users. In this phase the average
power rating of the server is about 110 Watts (green),
while simultaneously serving 15 users with a waiting time
way under one second. In one hour the system with 15
simultaneous users consumes 110 Wh = 396kJ.
The same measurement is performed with 25 simultane-
ous served users (cf. figure 5), whereas the average queued
users is approximately 17, which means that users have to
wait a little bit longer than in the measurement with 15 users,
but still get their response under one second. The energy
consumed is also 110 Watts and users can still be served at a
satisfactory time. As one can see, the claimed response time
plays a key role: the higher the demand for fast response,
the lower is the energy efficiency. Table I shows the average
consumption after one hour in both cases.
Figure 5. Energy Consumption Serving 15 (Top) and 25 (Bottom) Users
The procedure that we discussed and presented in this
paper works and produces beneficial results. This means
that energy consumption of specific parts of software can
be measured with a white box method and programmers are
able to find resource intensive code, which is an advantage
compared to black box methods. From the programmer’s
point of view, there is yet a lot of additional work.
Not only the exemplary set-up, also the development of
adequate metrics and the instrumentation cause a significant
overhead when the application becomes more complex.
There is by now no ready-to-use software or library for
source code instrumentation in context of energy efficiency
measurement. Furthermore, a professional power meter is
needed, which can be very expensive depending on the
desired application. In larger software projects maybe more
than one power meter will be necessary which causes
additional costs. After all the overhead for setting up a
measure environment and instrumenting source code, the
measurement itself is circumstantial. To conclude, we
evaluate the procedure as feasible for research but yet too
complex for every-day use in software projects.
The measurements and the metrics presented in this paper
should take place in a software development project as
early as possible. In principle, this means that even early
executable software artifacts should be examined regarding
energy efficiency issues. Due to the high affinity of the
method regarding performance measurements, its workload
can be re-used for this purpose and vice versa. In this way,
it is possible to combine performance and energy efficiency
measurement efforts. In accordance with continuously inte-
gration paradigms, we propose that the measurement runs
are automatically executed by build tools e.g. during nightly
builds. This leads to a database of measures that can be
used for an ongoing optimization of the software product.
Regarding metrics, an initial or preceding measure is used
as a reference value for succeeding measures, which enables
those responsible to calculate delta values, which can be
used as a distance metric for the optimization or to visualize
the outcomes of the energy optimization efforts in charts.
The amount of publications in the fields of green and
sustainable software, and the resulting demand for metrics
to measure sustainability aspects, show the importance of
the development of tools and guidelines for developers and
users of software. The small number of sophisticated in-
dustrial solutions demands an increased effort in developing
tools. In industry some pioneer projects, such as Intel’s
Energy Checker SDK, already exist, but it is still not a
widespread topic. Manual source code instrumentation is a
way to measure software, but is an additional expenditure
for developers. Automated instrumentation or at least semi-
automated instrumentation would be a large enhancement.
When instrumenting the code, the possibility to use the IDE
to set counters just like adding a breakpoint for debugging
would have been an enormous benefit.
Modern open source IDEs have the ability to have add-ons or
plug-ins developed. To our knowledge, such an extension for
energy measurement of desktop and server CPUs does not
yet exist. Besides the additional effort, another disadvantage
of the method is the need for hardware devices that measure
energy consumption. In the future, measurement should
be centralized and the results of measurements should be
aggregated to have more efficient power models that can be
used by others. Profilers would be able to use these models
to estimate energy consumption of software. A specific
function on a specific system would use approximately
the same amount of energy. Therefore, an instrumentation
on compiler level is needed where the compilers add in-
formation for energy debugging into the code. The more
systems are measured, the better the power models will
become. In combination with the power models, the profiler
should then be able to give an accurate prediction of energy
consumption. It has yet to be proven, if these energy models
supersede hardware-based measurement of software. Based
on robust metrics and measuring methods, the development
of seals of quality will be an important step for sustainable
software. As known from the application of other seals, they
create user awareness and encourage software vendors to
develop energy saving software products.
[1] Brown David and Reams Charles, “Toward Energy- Efficient
Computing: What will it take to make server-side computing
more energy efficient?” Communications of the ACM, vol. 53,
no. 3, pp. 50–59, 2010.
[2] S. Naumann, M. Dick, E. Kern, and T. Johann, “The
GREENSOFT Model: A Reference Model for Green and
Sustainable Software and its Engineering, Sustainable
Computing: Informatics and Systems, vol. 1, no. 4, pp.
294–304, 2011. [Online]. Available: doi:10.1016/j.suscom.
[3] J. Tayeb, K. Bross, B. S. Chang, L. Cong, and S. Rogers,
“Intel Energy Checker Software Development Kit User
Guide, 2010-12-15. [Online]. Available:
[4] M. Dick, E. Kern, J. Drangmeister, S. Naumann, and T. Jo-
hann, “Measurement and Rating of Software-induced Energy
Consumption of Desktop PCs and Servers, in Innovations in
sharing environmental observations and information, W. Pill-
mann, S. Schade, and P. Smits, Eds. Aachen: Shaker, 2011,
pp. 290–299.
... Year Proposed de¯nition Tate [7] 2005 Sustainability in SE is a development which balances the rapid release and long-term sustainability Dick et al. [8] 2010 Sustainable software is a software, whose direct and indirect negative impacts on economy, society, human beings, and environment that result from development, deployment, and usage of the software are minimal and/or which has a positive e®ect on sustainable development Penzenstadler [9] 2013 Sustainability is an ability for preserving the function of a system over a de¯ned time span Software Sustainability Institute [10] 2014 The software you use today will be available and continue to be improved and supported in the future Becker et al. [11] 2016 Systems sustainability describes how well the system will continue to exist and function, even as circumstances change Nakagawa et al. [12] 2018 The capacity of software system to endure over the time proposed four assets of sustainability measurement: infrastructure, people, processes, and product. The studies by Johann et al. [14] and Kern et al. [15] demonstrated a practical way of evaluating the sustainability criteria of a particular software system. ...
... It is still challenging to practically assess the level of achievement. Several studies have been conducted to practically evaluate sustainability achievement [14,15]. However, these studies only focus on one sustainability dimension: environmental. ...
... Meanwhile, we have the same sustainability coverage with Albertao et al. [21], in terms of the social, economic, and environmental dimensions. For potential improvements other than Johann et al. [14], all the studies present indicators for improving the sustainability achievement of each software. In terms of traceability, our proposed approach provides a sustainability matrix in which we exhibit the achievements of each feature. ...
Software sustainability evaluation has become an essential component of software engineering (SE) owing to sustainability considerations that must be incorporated into software development. Several studies have been performed to address the issues associated with sustainability concerns in the SE process. However, current practices extensively rely on participant experiences to evaluate sustainability achievement. Moreover, there exist limited quantifiable methods for supporting software sustainability evaluation. Our primary objective is to present a methodology that can assist software engineers in evaluating a software system based on well-defined sustainability metrics and measurements. We propose a novel approach that combines machine learning (ML) and software analysis methods. To simplify the application of the proposed approach, we present a semi-automated tool that supports engineers in assessing the sustainability achievement of a software system. The results of our study demonstrate that the proposed approach determines sustainability criteria and defines sustainability achievement in terms of a traceable matrix. Our theoretical evaluation and empirical study demonstrate that the proposed support tool can help engineers identify sustainability limitations in a particular feature of a software system. Our semi-automated tool can identify features that must be revised to enhance sustainability achievement.
... nachhaltige Software als Software, "(…) whose direct and indirect negative impacts on economy, society, human beings, and environment that result from development, deployment, and usage of the software are minimal and/or which has a positive effect on sustainable development" verstehen [Na11, S. 296]. Auf einem solchen, inhaltlich umfassenden Verständnis aufbauend, wurden Messmethoden [Jo12] und Kriterien entwickelt, um mittels eines Labels oder Siegels allen Anspruchsgruppen, und insbesondere den NutzerInnen, eine Beurteilungsgrundlage zur Nachhaltigkeit von Software zu ermöglichen [Ke15]. Im Forschungsprojekt UFOPLAN-SSD 2015 wurde eine konkrete Methodik zur Bewertung der Ressourceneffizienz von Softwareprodukten entwickelt [Gr18], die im Folgeprojekt Refoplan 2018 zu einer Vergabegrundlage [KN20] und schließlich zu den ersten Vergabekriterien des Blauen Engels für "Ressourcen-und energieeffiziente Softwareprodukte (DE-UZ 215)" 2 ausgebaut wurde. ...
Conference Paper
Full-text available
In den Vergabekriterien des Umweltzeichens Blauer Engel für „Ressourcen- und energieeffiziente Softwareprodukte“ liegt der Fokus auf der Nutzungsphase von Software und deren NutzerInnen als zentrale Zielgruppe. Den NutzerInnen wird eine besondere Rolle bei der Reduktion des Energieverbrauchs der Informations- und Kommunikationstechnik (IKT) und der Steigerung der Ressourceneffizienz zugesprochen. In der Forschung zur Green IT findet diese Zielgruppe bislang jedoch wenig Beachtung. Dem Ruf nach einer transdisziplinären Betrachtung folgend, ergänzt dieser Beitrag die bestehende Forschung um eine verhaltenswissenschaftliche Perspektive. Mit Hilfe von leitfadengestützten Interviews wird die Frage untersucht, welches implizite Verständnis NutzerInnen von Software und Updates haben und welche Erwartungen sie an diese stellen. Die abgeleiteten User Insights tragen zur Schließung der bestehenden Forschungslücke bei und liefern Impulse für eine Weiterentwicklung der Kriterien des Blauen Engels für „Ressourcen- und energieeffiziente Softwareprodukte“.
... However, the early works of software sustainability mostly focus on environmental dimension. 15, 16 Rodriguez and Penzenstadler 17 proposed a technique to assess sustainability in a software system. The author showed the way sustainability indicators are identified and reviewed in meta-scenario-making. Becker et al 6 described an initiative to create a common ground to develop a focal point of reference on incorporating sustainability thinking into software design. ...
Due to the critical role of a software‐intensive system in society, software engineers have a responsibility to add sustainability as a goal while developing a software system. However, there is a lack of practical guidelines providing a tangible decomposition of the sustainability aspect. Moreover, there are limited quantifiable methods to support sustainable design and analysis. Therefore, we propose a systematic approach that allows software practitioners to accommodate sustainability concerns that are aligned with other software quality attributes to enhance sustainable development. By using the combination of a goal‐scenario‐based approach and feature modeling, sustainability requirements are elicited along with their functional compositions. Our approach is a comprehensive reference model that decomposes sustainability requirements, enabling analysis, support, and assessment of sustainability risk analysis and guiding the designer to construct a feature model as a system functional decomposition. From the conducted theoretical evaluation and empirical study, our proposed approach can derive more significant sustainability‐related requirements and key features by providing a practical guideline with the integration of well‐known methods to address sustainability in requirements engineering. With the help of the provided approach, we can solve more conflicting goals in different sustainability dimensions. Our approach is a comprehensive reference model that decomposing sustainability requirements, enabling analysis, support, and assessment of sustainability risk analysis and guiding the designer to construct a feature model as a system functional decomposition. From the conducted theoretical evaluation and empirical study, our proposed approach can derive more significant sustainability‐related requirements and key features by providing a practical guideline with the integration of well‐known methods to address sustainability in requirements engineering.
... Johann, Dick, Nauman n and Kern [50] 201 2 ...
Full-text available
Background: Main asset in software industry is knowledge of employees who work in software development. Knowledge is main asset to succeed in green sustainable development. There is no research about to implement tech-niques of Knowledge Management (KM) in order to help in managing knowledge of Green Software Development (GSD). This is the research gap. Aims: This paper assesses literature on GSD in regards to the evolution of green computing, and discusses about how KM comes in to assist in managing the knowledge of GSD. Method: This study reviews current status of GSD by using tertiary study to review articles. A standard systematic litera-ture review method is carried out to employ a manual search. Focus domains, knowledge areas and measurements of GSD will be identified so that can distill a common understanding of the state-of-the-art GSD. Then, discussion about how KM comes in to assist CoP in managing their knowledge of GSD will be carried out in detailed. Results: 37 articles are chosen as primary studies. Among all focus domains, GSD life cycle gains highest interest. Knowledge area of energy efficiency receives the highest attention. Measurement for power consumption obtains the greatest priority to measure “greenness” of software devel-oped. Conclusion: Focuses covered by GSD are limited. Re-searchers are encouraged to study about diverse areas of GSD. Our future work is to develop model of GSD which involving KM process to ensure members of CoP in soft-ware environment able to manage their knowledge and sus-tain best practices of GSD for the future.
... This is how the power of Knowledge Management (KM) comes in to this concern. Several researchers studied about GSD and the green practices [5,6,7,8]. However, no one study about how to manage and share the green practices of GSD to other software developers efficiently. ...
Full-text available
Green Software Development (GSD) is about adopting green practices in Software Development Life Cycle towards developing environmentally-friendly software products. GSD is knowledge-intensive project, which is heavily depending on sharing of green practices in Community of Practice (CoP) to develop greener software products. As knowledge sharing is an important activity in Knowledge Management (KM), this is how the power of KM comes in to support GSD. However, there is a lack of KM application in managing green knowledge of GSD. To address the research gap, this paper suggests an implementation of agent technology together with KM application in helping CoP to share knowledge of GSD. Based on Literature Review, a conceptual architecture of agent-based KM System (KMS) is proposed, with the aim of studying on how multi-agent system and KMS are working together efficiently to enhance knowledge sharing in GSD environment.
... This section presents the results obtained from consumption measurements for the methods described in Section 3. Table 2 shows an overview of the results measured with both methods. The efficiency factor is calculated, based upon the metrics proposed in [14], where, in this case, we use the number of sorted items (1.5156×10 9 ) as the "useful work done": ...
Conference Paper
As part of Green IT, the field of green software engineering has seen a rise in interest over the past years. Several methods for as- sessing the energy efficiency of software were devised, which are partially based upon rather different approaches and partially come to similar conclusions. In this paper, we take an in-depth look at two methods for assessing the resource consumption that is induced by software. We de- scribe the methods along a case study, where we measured five sorting algorithms and compared them in terms of similarities, differences and synergies. We show that even though the methods use different mea- surement approaches (intrusive vs. non-intrusive), the results are indeed comparable and combining the methods can improve the findings.
... The study focused on energy consumption of CPU and network demanding software at different levels of granularity. Also, the formula proposed for software energy efficiency (EF) is UsefulWorkDone/UserdEnergy [38]. This generic measure provide a way for evaluating the energy consumption of different software parts and modules using white box testing to measure which parts are consuming more energy and to see which parts can be optimized for efficient energy usage. ...
Conference Paper
Full-text available
Energy efficiency is one of the very few measures widely used for evaluating green and sustainable software systems. This paper investigates the current measures of software sustainability from the four different software sustainability perceptions: Sustainability in Software Development, Green Software Systems, Software for Sustainability, Sustainability of the Software Eco System and Software Sustainability Dimensions (Economic, Social, Individual, Technical and Environment). While exploring the literature on green and sustainable software systems, measures of green software and software sustainability were identified, compiled and classified according to the four sustainability perceptions.
Almost all products, systems and activities leave an ecological footprint. For this reason, sustainability has become a central requirement of today's world. To date, this applies to software products only to a lesser extent. Nevertheless, recent developments such as the introduction of the Blue Angel as a label for energy- and resource-efficient software are continuously drawing more attention to this issue. One focus of research on this topic is the energy efficiency of these applications. Since software is used in different areas in many different architectures, a variety of factors influencing the respective power consumption are conceivable. Client-server architectures offer a special application case. Not only can the implementation of the algorithms influence the power consumption, but also the location where the computations are executed. This paper therefore investigates the influence of different load distributions on the energy efficiency of these architectures. The results obtained suggest that sometimes serious differences arise due to different calculation locations. These differences are due to multiple factors. Knowledge about this not only enables a more accurate assessment of the energy efficiency of web applications, but can also serve as a principle of sustainable web development and help developers to reduce the ecological footprint of their applications.
Unmanned Aerial Vehicles (UAVs), as a recently emerging technology, enabled a new breed of unprecedented applications in different domains. This technology’s ongoing trend is departing from large remotely-controlled drones to networks of small autonomous drones to collectively complete intricate tasks time and cost-effectively. An important challenge is developing efficient sensing, communication, and control algorithms that can accommodate the requirements of highly dynamic UAV networks with heterogeneous mobility levels. Recently, the use of Artificial Intelligence (AI) in learning-based networking has gained momentum to harness the learning power of cognizant nodes to make more intelligent networking decisions by integrating computational intelligence into UAV networks. An important example of this trend is developing learning-powered routing protocols, where machine learning methods are used to model and predict topology evolution, channel status, traffic mobility, and environmental factors for enhanced routing. This paper reviews AI-enabled routing protocols designed primarily for aerial networks, including topology-predictive and self-adaptive learning-based routing algorithms, with an emphasis on accommodating highly-dynamic network topology. To this end, we justify the importance and adaptation of AI into UAV network communications. We also address, with an AI emphasis, the closely related topics of mobility and networking models for UAV networks, simulation tools and public datasets, and relations to UAV swarming, which serve to choose the right algorithm for each scenario. We conclude by presenting future trends, and the remaining challenges in AI-based UAV networking, for different aspects of routing, connectivity, topology control, security and privacy, energy efficiency, and spectrum sharing.
With the resource-constrained nature of mobile devices, and the resource-abundant offerings of the cloud, several promising optimization techniques have been proposed by the green computing research community. Prominent techniques and unique methods have been developed to offload resource-/computation-intensive tasks from mobile devices to the cloud. Most of the existing offloading techniques can only be applied to legacy mobile applications as they are motivated by existing systems. Consequently, they are realized with custom runtimes, which incurs overhead on the application. Moreover, existing approaches which can be applied to the software development phase are difficult to implement (based on manual process) and also fall short of overall (mobile to cloud) efficiency in software quality attributes or awareness of full-tier (mobile to cloud) implications.
The resource and power consumption of ICT is still increasing, but also the benefits of ICT, e.g. in finding more efficient solutions for environmental problems. To date, it is not clear, whether the resource and energy savings through ICT overbalance the resource and energy consumption by ICT, or not. Up to now, manifold efforts of Green IT address the environmental aspects of sustainability considering computer hardware. However, there is still a lack of models, descriptions or realizations in the area of computer software and software process models. In our contribution, we first propose definitions of the terms “Green and Sustainable Software” and “Green and Sustainable Software Engineering”, then we outline a conceptual reference model, the GREENSOFT Model. This model includes a cradle-to-grave product life cycle model for software products, sustainability metrics and criteria for software, software engineering extensions for sustainably sound software design and development, as well as appropriate guidance.
Intel Energy Checker Software Development Kit User Guide
  • J Tayeb
  • K Bross
  • B S Chang
  • L Cong
  • S Rogers
J. Tayeb, K. Bross, B. S. Chang, L. Cong, and S. Rogers, "Intel Energy Checker Software Development Kit User Guide," 2010-12-15. [Online]. Available: com/file/32957/