Developing Energy-Aware Software

Steven te Brinke

    Research output: ThesisPhD Thesis - Research UT, graduation UT

    52 Downloads (Pure)

    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
    • Akşit, Mehmet , Supervisor
    • Bockisch, Christoph, Advisor
    Thesis sponsors
    Award date4 Jun 2015
    Place of PublicationEnschede
    Publisher
    Print ISBNs978-90-365-3875-6
    DOIs
    Publication statusPublished - 4 Jun 2015

    Keywords

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

    Cite this

    te Brinke, S. (2015). Developing Energy-Aware Software. Enschede: University of Twente. https://doi.org/10.3990/1.9789036538756
    te Brinke, Steven. / Developing Energy-Aware Software. Enschede : University of Twente, 2015. 175 p.
    @phdthesis{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",
    day = "4",
    doi = "10.3990/1.9789036538756",
    language = "Undefined",
    isbn = "978-90-365-3875-6",
    publisher = "University of Twente",
    address = "Netherlands",
    school = "University of Twente",

    }

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

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

    Enschede : University of Twente, 2015. 175 p.

    Research output: ThesisPhD 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

    PB - University of Twente

    CY - Enschede

    ER -

    te Brinke S. Developing Energy-Aware Software. Enschede: University of Twente, 2015. 175 p. https://doi.org/10.3990/1.9789036538756