762 research outputs found
Identifying Compiler Options to Minimise Energy Consumption for Embedded Platforms
This paper presents an analysis of the energy consumption of an extensive
number of the optimisations a modern compiler can perform. Using GCC as a test
case, we evaluate a set of ten carefully selected benchmarks for five different
embedded platforms.
A fractional factorial design is used to systematically explore the large
optimisation space (2^82 possible combinations), whilst still accurately
determining the effects of optimisations and optimisation combinations.
Hardware power measurements on each platform are taken to ensure all
architectural effects on the energy consumption are captured.
We show that fractional factorial design can find more optimal combinations
than relying on built in compiler settings. We explore the relationship between
run-time and energy consumption, and identify scenarios where they are and are
not correlated.
A further conclusion of this study is the structure of the benchmark has a
larger effect than the hardware architecture on whether the optimisation will
be effective, and that no single optimisation is universally beneficial for
execution time or energy consumption.Comment: 14 pages, 7 figure
Area-energy aware dataflow optimisation of visual tracking systems
This paper presents an orderly dataflow-optimisation approach suitable for area-energy aware computer vision applications on FPGAs. Vision systems are increasingly being deployed in power constrained scenarios, where the
dataflow model of computation has become popular for describing complex algorithms. Dataflow model allows processing datapaths comprised of several independent
and well defined computations. However, compilers are often unsuccessful in identifying domain-specific optimisation opportunities resulting in wasted
resources and power consumption. We present a methodology for the optimisation of dataflow networks, according to patterns often found in computer vision systems, focusing on identifying optimisations which are not discovered automatically by an optimising compiler. Code transformation using profiling and refactoring
provides opportunities to optimise the design, targeting FPGA implementations and focusing on area and power abatement. Our refactoring methodology, applying transformations to a complex algorithm for visual tracking resulted in significant reduction in power consumption and resource usage
A hardware mechanism to reduce the energy consumption of the register file of in-order architectures
This paper introduces an efficient hardware approach to reduce the register file energy consumption by turning unused registers into a low power state. Bypassing the register fields of the fetch instruction to the decode stage allows the identification of registers required by the current instruction (instruction predecode) and allows the control logic to turn them back on. They are put into the low-power state after the instruction use. This technique achieves an 85% energy reduction with no performance penalty
Chapter Energy-Aware Software Engineering
Polystyrene (PS) is a petroleumâbased plastic made from styrene (vinyl benzene) monomer. Since it was first commercially produced in 1930, it has been used for a wide range of commercial, packaging and building purposes. In 2012, approximately 32.7 million tonnes of styrene were produced globally, and polystyrene is now a ubiquitous household item worldwide. In 1986, the US Environmental Protection Agency (EPA) announced that the polystyrene manufacturing process was the fifth largest source of hazardous waste. Styrene has been linked to adverse health effects in humans, and in 2014, it was listed as a possible carcinogen. Yet, despite mounting evidence and public concern regarding the toxicity of styrene, the product of the polymerisation of styrene, PS, is not considered hazardous. This chapter draws on a series of movements called the ânew materialismsâ to attend to the relational, unstable and contingent nature of PS, monomers and other additives in diverse environments, and thus, we highlight the complexities involved in the categorisation of PS as âhazardousâ and the futility of demarcating PS as âhousehold waste'. While local examples are drawn from the New Zealand context, the key messages are transferrable to most policy contexts and diverse geographical locations
Energy-Aware Software Engineering
A great deal of energy in Information and Communication Technology (ICT) systems can be wasted by software, regardless of how energy-efficient the underlying hardware is. To avoid such waste, programmers need to understand the energy consumption of programs during the development process rather than waiting to measure energy after deployment. Such understanding is hindered by the large conceptual gap from hardware, where energy is consumed, to high-level languages and programming abstractions. The approaches described in this chapter involve two main topics: energy modelling and energy analysis. The purpose of modelling is to attribute energy values to programming constructs, whether at the level of machine instructions, intermediate code or source code. Energy analysis involves inferring the energy consumption of a program from the program semantics along with an energy model. Finally, the chapter discusses how energy analysis and modelling techniques can be incorporated in software engineering tools, including existing compilers, to assist the energy-aware programmer to optimise the energy consumption of code
ENTRA:Whole-systems energy transparency
Promoting energy efficiency to a first class system design goal is an
important research challenge. Although more energy-efficient hardware can be
designed, it is software that controls the hardware; for a given system the
potential for energy savings is likely to be much greater at the higher levels
of abstraction in the system stack. Thus the greatest savings are expected from
energy-aware software development, which is the vision of the EU ENTRA project.
This article presents the concept of energy transparency as a foundation for
energy-aware software development. We show how energy modelling of hardware is
combined with static analysis to allow the programmer to understand the energy
consumption of a program without executing it, thus enabling exploration of the
design space taking energy into consideration. The paper concludes by
summarising the current and future challenges identified in the ENTRA project.Comment: Revised preprint submitted to MICPRO on 27 May 2016, 23 pages, 3
figure
Modular Remote Reprogramming of Sensor Nodes
Wireless sensor networks are envisioned to be deployed in the absence of permanent network infrastructure and in environments with limited or no human accessibility. Hence, such deployments demand mechanisms to remotely (i.e., over the air) reconfigure and update the software on the nodes. In this paper we introduce DyTOS, a TinyOS based remote reprogramming approach that enables the dynamic exchange of software components and thus incrementally update the operating system and its applications. The core idea is to preserve the modularity of TinyOS, i.e., its componentisation, which is lost during the normal compilation process, and enable runtime composition of TinyOS components on the sensor node. The proposed solution integrates seamlessly into the system architecture of TinyOS: It does not require any changes to the programming model of TinyOS and all existing components can be reused transparently. Our evaluation shows that DyTOS incurs a low performance overhead while keeping a smaller â up to one third â memory footprint than other comparable solutions
An automated OpenCL FPGA compilation framework targeting a configurable, VLIW chip multiprocessor
Modern system-on-chips augment their baseline CPU with coprocessors and accelerators to increase overall computational capacity and power efficiency, and thus have evolved into heterogeneous systems. Several languages have been developed to enable this paradigm shift, including CUDA and OpenCL. This thesis discusses a unified compilation environment to enable heterogeneous system design through the use of OpenCL and a customised VLIW chip multiprocessor (CMP) architecture, known as the LE1. An LLVM compilation framework was researched and a prototype developed to enable the execution of OpenCL applications on the LE1 CPU. The framework fully automates the compilation flow and supports work-item coalescing to better utilise the CPU cores and alleviate the effects of thread divergence. This thesis discusses in detail both the software stack and target hardware architecture and evaluates the scalability of the proposed framework on a highly precise cycle-accurate simulator. This is achieved through the execution of 12 benchmarks across 240 different machine configurations, as well as further results utilising an incomplete development branch of the compiler. It is shown that the problems generally scale well with the LE1 architecture, up to eight cores, when the memory system becomes a serious bottleneck. Results demonstrate superlinear performance on certain benchmarks (x9 for the bitonic sort benchmark with 8 dual-issue cores) with further improvements from compiler optimisations (x14 for bitonic with the same configuration
- âŠ