| Smart things, spaces, and structures are created by embedding computation into them. Embedded computers sense, compute, and communicate at the edge, closer to the physical rather than the cyber world. Not any computer can be embedded, because many deployment settings demand small size, long lifetime, and robustness to a harsh environment. The energy source of the computer -- traditionally a battery -- is the most likely component to fail to meet these constrains. Batteries have a limited lifetime, degrade over time, are bulky, cannot tolerate low temperatures, and are costly to replace. A promising alternative power source is an energy-harvesting circuit that extracts solar, mechanical, radio, or thermal energy from its environment. Computers powered by energy harvesters (EHCs) are a promising platform for wearable or ingestible medical devices, industrial or environmental monitoring, and scientific instruments.;From the programmer's perspective, however, it is uniquely challenging to develop software for an energy-harvesting computer than for a traditional battery-powered embedded computer. Software that runs correctly on a battery-powered platform may produce incorrect results or fail to complete at all and is more difficult to debug on an EHC. Software execution on an EHC is intermittent , because the device is on for brief intervals, only when sufficient energy is available, and is abruptly interrupted on each power failure. The work in this thesis identifies the challenges of computing reliably and efficiently on intermittently-powered energy-harvesting platforms. We address the challenges of intermittent computing through support across the system stack, from the programming model and runtime systems to hardware mechanisms and tools for program analysis and diagnostics.;The first challenge of intermittent program execution is maintaining progress across power failures and keeping the program state consistent in memory. Prior work has proposed checkpointing mechanisms for maintaining the program state across power failures. We expose the overhead of checkpoints and approach this problem differently, with a new programming model for intermittent software, named Chain. A Chain program is a set of programmer-defined tasks that compute and exchange data through persistent channels. Chain programs span power failures by completing at least one task between each two power failures. A task can be safely restarted after a power failure and will never see inconsistent state in memory, because its inputs and outputs are in separate channels in memory. We implement Chain abstractions as a library for use with the C language and demonstrate that it ensures correct results despite power failures and reduces performance overhead by 2-7x compared to a checkpointing system for a set of embedded applications.;Task-based programming models, like Chain, allow intermittent execution of long-running applications, but require the programmer to decompose code into tasks. However, some task decompositions prevent the program from terminating or executing efficiently. Programs decomposed into tasks larger than the work executable on stored energy will repeatedly re-execute a task and never terminate. On the other hand, a decomposition that fragments the program into small tasks has to spend more time and energy persisting program state across tasks. We propose CleanCut, a tool that can check for and report non-termination in a given task decomposition, as well as automatically decompose code into valid tasks. To reason about energy consumption, CleanCut relies on a statistical model for the energy of a program path, derived from measured energy consumption of basic blocks. We applied CleanCut to a set of benchmark applications, to demonstrate a non-terminating path report and a performance improvement of 2.45x using automatic decomposition relative to manual decompositions from prior work.;Tasks in a program may have different preferred modes of execution, i.e. the frequency and duration of each execution. Multiple modes are achievable using the same total energy by using it differently over time. However, software cannot control when the device is off and accumulates energy and for how long it stays on each time it uses stored energy, since this is a function of energy storage capacity and input power. We develop Capybara, a hardware power system with an energy capacity that is reconfigurable at runtime. Capybara grants software some control over when and how much energy is provided to which task. The Capybara software interface allows programmers to associate modes with application tasks, and the runtime system reconfigures hardware energy capacity to match the declared mode. Capybara allows a programmer to write reactive application tasks that pre-allocate a burst of energy that it can spend in response to an asynchronous external event. (Abstract shortened by ProQuest.). |
