Abstract

Awareness of environmental sustainability, together with an increasing use of software, makes optimization of software energy consumption evermore important. Energy is one of many resources that is managed by software, and reducing energy consumption cannot be considered without taking into account the trade-offs with other resources and services. Optimization techniques, implemented in software, can lead to substantial reduction of resource consumption, within both the computer system and the system being controlled. This thesis focusses on the reduction of energy consumption by controlling various external hardware components that are energy intensive. Today's software faces the problem of complexity, and modularization is considered as means to cope with the complexity of software. Therefore, we modularized energy optimizers from the rest of the software. This thesis introduces a modeling notation that supports energy behavior. Our notation is used to understand the energy behavior of the system and to analyze which control strategy reduces the energy consumption. We also present guidelines for designing models that contain energy behavior and present a method to automatically extract models, including energy behavior, from source code together with profiling of the application. These Resource-Utilization Models (RUMs) are over-abstractions of the application and can be analyzed formally, for example, with the model checker Uppaal. Energy is actually consumed during the execution of the software. Therefore, it is inevitable to carry out optimizations at runtime. In order to support such software design, it must be possible to reuse the energy models at runtime without compromising the modularity of the implementation. However, fully supporting our models in a mainstream programming language reduces the readability of the source code. Therefore, this thesis introduces a programming language, named Co-op, that aims to address this issue. Co-op can be positioned between Aspect-Oriented Programming (AOP) and a Meta-Object Protocol (MOP): it is less expressive than a full MOP, but more expressive than AOP. This way, it supports all operations needed for implementing our models, because as well too expressive as too limiting languages reduce the readability of the source code. Combining design and implementation support for Resource-Utilization Models allows software developers to optimize the energy consumption of their software in a modular way. This reduces the energy footprint of software while improving its maintainability and understandability. Hopefully, our approach will be adopted in practice to create a better planet with higher quality software.
Original languageUndefined
Awarding Institution
  • University of Twente
Supervisors/Advisors
  • Aksit, Mehmet , Supervisor
  • Advisor
Sponsors
Date of Award4 Jun 2015
Place of PublicationEnschede
Print ISBNs978-90-365-3875-6
DOIs
StatePublished - 4 Jun 2015

Fingerprint

Energy utilization
Aspect oriented programming
Computer programming languages
Maintainability
Planets
Software design
Sustainable development
Computer systems
Hardware

Keywords

  • IR-95960
  • METIS-310556
  • EWI-26004

Cite this

te Brinke, S. (2015). Developing Energy-Aware Software Enschede DOI: 10.3990/1.9789036538756
te Brinke, Steven. / Developing Energy-Aware Software. Enschede, 2015. 175 p.
@misc{2527c57367374a78ba23af7160042441,
title = "Developing Energy-Aware Software",
abstract = "Awareness of environmental sustainability, together with an increasing use of software, makes optimization of software energy consumption evermore important. Energy is one of many resources that is managed by software, and reducing energy consumption cannot be considered without taking into account the trade-offs with other resources and services. Optimization techniques, implemented in software, can lead to substantial reduction of resource consumption, within both the computer system and the system being controlled. This thesis focusses on the reduction of energy consumption by controlling various external hardware components that are energy intensive. Today's software faces the problem of complexity, and modularization is considered as means to cope with the complexity of software. Therefore, we modularized energy optimizers from the rest of the software. This thesis introduces a modeling notation that supports energy behavior. Our notation is used to understand the energy behavior of the system and to analyze which control strategy reduces the energy consumption. We also present guidelines for designing models that contain energy behavior and present a method to automatically extract models, including energy behavior, from source code together with profiling of the application. These Resource-Utilization Models (RUMs) are over-abstractions of the application and can be analyzed formally, for example, with the model checker Uppaal. Energy is actually consumed during the execution of the software. Therefore, it is inevitable to carry out optimizations at runtime. In order to support such software design, it must be possible to reuse the energy models at runtime without compromising the modularity of the implementation. However, fully supporting our models in a mainstream programming language reduces the readability of the source code. Therefore, this thesis introduces a programming language, named Co-op, that aims to address this issue. Co-op can be positioned between Aspect-Oriented Programming (AOP) and a Meta-Object Protocol (MOP): it is less expressive than a full MOP, but more expressive than AOP. This way, it supports all operations needed for implementing our models, because as well too expressive as too limiting languages reduce the readability of the source code. Combining design and implementation support for Resource-Utilization Models allows software developers to optimize the energy consumption of their software in a modular way. This reduces the energy footprint of software while improving its maintainability and understandability. Hopefully, our approach will be adopted in practice to create a better planet with higher quality software.",
keywords = "IR-95960, METIS-310556, EWI-26004",
author = "{te Brinke}, Steven",
note = "IPA dissertation series no. 2015-16",
year = "2015",
month = "6",
doi = "10.3990/1.9789036538756",
isbn = "978-90-365-3875-6",
school = "University of Twente",

}

te Brinke, S 2015, 'Developing Energy-Aware Software', University of Twente, Enschede. DOI: 10.3990/1.9789036538756

Developing Energy-Aware Software. / te Brinke, Steven.

Enschede, 2015. 175 p.

Research output: ScientificPhD Thesis - Research UT, graduation UT

TY - THES

T1 - Developing Energy-Aware Software

AU - te Brinke,Steven

N1 - IPA dissertation series no. 2015-16

PY - 2015/6/4

Y1 - 2015/6/4

N2 - Awareness of environmental sustainability, together with an increasing use of software, makes optimization of software energy consumption evermore important. Energy is one of many resources that is managed by software, and reducing energy consumption cannot be considered without taking into account the trade-offs with other resources and services. Optimization techniques, implemented in software, can lead to substantial reduction of resource consumption, within both the computer system and the system being controlled. This thesis focusses on the reduction of energy consumption by controlling various external hardware components that are energy intensive. Today's software faces the problem of complexity, and modularization is considered as means to cope with the complexity of software. Therefore, we modularized energy optimizers from the rest of the software. This thesis introduces a modeling notation that supports energy behavior. Our notation is used to understand the energy behavior of the system and to analyze which control strategy reduces the energy consumption. We also present guidelines for designing models that contain energy behavior and present a method to automatically extract models, including energy behavior, from source code together with profiling of the application. These Resource-Utilization Models (RUMs) are over-abstractions of the application and can be analyzed formally, for example, with the model checker Uppaal. Energy is actually consumed during the execution of the software. Therefore, it is inevitable to carry out optimizations at runtime. In order to support such software design, it must be possible to reuse the energy models at runtime without compromising the modularity of the implementation. However, fully supporting our models in a mainstream programming language reduces the readability of the source code. Therefore, this thesis introduces a programming language, named Co-op, that aims to address this issue. Co-op can be positioned between Aspect-Oriented Programming (AOP) and a Meta-Object Protocol (MOP): it is less expressive than a full MOP, but more expressive than AOP. This way, it supports all operations needed for implementing our models, because as well too expressive as too limiting languages reduce the readability of the source code. Combining design and implementation support for Resource-Utilization Models allows software developers to optimize the energy consumption of their software in a modular way. This reduces the energy footprint of software while improving its maintainability and understandability. Hopefully, our approach will be adopted in practice to create a better planet with higher quality software.

AB - Awareness of environmental sustainability, together with an increasing use of software, makes optimization of software energy consumption evermore important. Energy is one of many resources that is managed by software, and reducing energy consumption cannot be considered without taking into account the trade-offs with other resources and services. Optimization techniques, implemented in software, can lead to substantial reduction of resource consumption, within both the computer system and the system being controlled. This thesis focusses on the reduction of energy consumption by controlling various external hardware components that are energy intensive. Today's software faces the problem of complexity, and modularization is considered as means to cope with the complexity of software. Therefore, we modularized energy optimizers from the rest of the software. This thesis introduces a modeling notation that supports energy behavior. Our notation is used to understand the energy behavior of the system and to analyze which control strategy reduces the energy consumption. We also present guidelines for designing models that contain energy behavior and present a method to automatically extract models, including energy behavior, from source code together with profiling of the application. These Resource-Utilization Models (RUMs) are over-abstractions of the application and can be analyzed formally, for example, with the model checker Uppaal. Energy is actually consumed during the execution of the software. Therefore, it is inevitable to carry out optimizations at runtime. In order to support such software design, it must be possible to reuse the energy models at runtime without compromising the modularity of the implementation. However, fully supporting our models in a mainstream programming language reduces the readability of the source code. Therefore, this thesis introduces a programming language, named Co-op, that aims to address this issue. Co-op can be positioned between Aspect-Oriented Programming (AOP) and a Meta-Object Protocol (MOP): it is less expressive than a full MOP, but more expressive than AOP. This way, it supports all operations needed for implementing our models, because as well too expressive as too limiting languages reduce the readability of the source code. Combining design and implementation support for Resource-Utilization Models allows software developers to optimize the energy consumption of their software in a modular way. This reduces the energy footprint of software while improving its maintainability and understandability. Hopefully, our approach will be adopted in practice to create a better planet with higher quality software.

KW - IR-95960

KW - METIS-310556

KW - EWI-26004

U2 - 10.3990/1.9789036538756

DO - 10.3990/1.9789036538756

M3 - PhD Thesis - Research UT, graduation UT

SN - 978-90-365-3875-6

ER -

te Brinke S. Developing Energy-Aware Software. Enschede, 2015. 175 p. Available from, DOI: 10.3990/1.9789036538756