Execution Continuity Across Intermittent Power Cycles

93 concepts47 papers

Traditional computing architectures operate under a fundamental assumption: power is continuous. When you turn a computer off, its volatile memory (SRAM, CPU registers) vanishes, and it boots from scratch upon the next power-up.

However, as the Internet of Things scales to billions of small, autonomous devices, relying on batteries introduces a massive maintenance bottleneck. This has driven a shift toward batteryless devices that harvest ambient energy from their surroundings—such as solar, vibration, thermal gradients, or RF signals, as discussed by Sliper et al. and Wong et al..

Because ambient energy is highly erratic, these devices experience frequent, unpredictable power failures. To prevent them from losing progress and getting trapped in infinite reboot loops, a new paradigm is required: intermittent computing.


The Problem of the Infinite Reboot Loop

When an embedded device relies on a tiny energy-harvesting capacitor instead of a battery, it operates in short bursts. It wakes up when the capacitor is full, executes code until the capacitor drains, and crashes.

Consider a computational task that requires 100 milliseconds of continuous execution. If the environment only provides enough ambient energy for 50-millisecond bursts, a traditional system will behave like this:

Burst 1 (50ms): Wakes up -> Executes first 50ms -> Power drops -> Crashes (Progress lost)
Burst 2 (50ms): Wakes up -> Reboots -> Executes same first 50ms -> Crashes (Progress lost)

Because the volatile state is wiped out at the end of every burst, the system is trapped in a perpetual reboot cycle, failing to make forward progress. As Sliper et al. and Maeng et al. point out, this non-termination failure mode prevents batteryless devices from completing any task longer than a single energy burst.

To solve this, we must treat power failures not as fatal crashes, but as pauses. This requires shifting from traditional execution models to an energy-driven paradigm, where the system state is preserved across power cycles, as argued by Merrett.


The Core Mechanism: Non-Volatile State Checkpointing

The fundamental mechanism behind intermittent computing is checkpointing: copying the volatile state of the processor (registers, stack, and heap) to Non-Volatile Memory (NVM) before power runs out, and restoring it when power returns. This allows long-running tasks to span multiple power cycles, as explained by Al-Hashimi et al. and Garg et al..

[ Volatile State (RAM/Registers) ] --(Save on Power Drop)--> [ Non-Volatile Memory (NVM) ]
                                                                      |
[ Volatile State (RAM/Registers) ] <--(Restore on Wakeup)------------+

The choice of NVM architecture is critical to making this work. Traditional Flash memory is poorly suited for intermittent computing because writing to it requires high voltage, high energy, and significant latency. The energy spent just writing the checkpoint could deplete the entire harvested energy burst, as noted by Verykios et al..

To bypass this bottleneck, intermittent architectures frequently utilize emerging non-volatile memories like Ferroelectric RAM (FRAM). As shown by Su et al. and Pentecost et al., FRAM combines the write speed and low power consumption of volatile SRAM with the persistence of Flash. By integrating FRAM directly into the microcontroller, devices can enter deep hibernation and resume execution almost instantly without the energy penalty of a traditional boot sequence, a mechanism leveraged by the authors of An Energy Neutral Wearable Camera with EPD Display and explored in low-power wide-area networks by Piyare et al..


Just-In-Time: Reactive Checkpointing

When should a device save its state?

One approach is proactive checkpointing, where the software periodically saves its state at fixed intervals. However, this introduces two major inefficiencies:

  1. It wastes precious energy saving state when power might actually be abundant.
  2. It creates a "rollback gap." If the system executes code for 10ms after a checkpoint and then crashes, that 10ms of work is lost. Upon recovery, the system must roll back to the last checkpoint, repeating work and wasting energy, as detailed by Zhang et al..

To maximize active compute time, systems use reactive checkpointing. Instead of guessing when power will fail, the system monitors the supply voltage in real-time using hardware interrupts, as explained by Merrett.

Voltage
  ^
  |  ======================== (Normal Operation)
  |                          \
  |                           \
--|----------------------------\------------------ Threshold V_crit (Trigger Checkpoint)
  |                             \::::::::::::::::: [Grace Period: State saved using residual energy]
  v                               \_______________ Zero Power
  +--------------------------------------------------------------------> Time

When the supply voltage drops below a critical threshold ($V_{crit}$), a hardware comparator triggers an immediate interrupt. The system then uses the residual energy stored in its small parasitic capacitances to perform a single, just-in-time state save to NVM before total power failure, a technique demonstrated by Merrett and Merrett.

To prevent unnecessary checkpointing overhead during minor, temporary power dips, Lukosevicius et al. introduced an intermediate "sleep" state. If the voltage drops slightly, the system pauses execution without saving state; it only commits a full hibernation checkpoint if the voltage continues to fall past the critical threshold.


Minimizing the State Burden

Even with fast memories like FRAM, checkpointing is not free. If a system has a large memory footprint, the energy required to write the entire state to NVM might exceed the total capacity of the hardware's energy buffer. If this happens, the system will crash during the checkpointing process, making forward progress impossible, as shown by Hsiu et al.. This overhead must be carefully balanced against the energy available for actual data processing, a challenge highlighted by Mishra et al. and the authors of Design-Time Optimization of Deep Neural Networks for Intermittent Learning on Microcontrollers.

To reduce this burden, researchers use several optimization strategies:

  • Selective State Retention: Instead of saving the entire physical address space, the system dynamically identifies and saves only the active memory regions currently in use, such as the stack and heap. Verykios et al. demonstrated that this approach can reduce the time and energy overhead of state retention by up to 85%.
  • Hardware-Assisted Data Flow Tracking: By using low-cost binary counters in hardware to track execution progress at the clock-cycle level, systems can pinpoint exactly what intermediate data needs to be saved. As shown by Zhang et al., this reduces rollback requirements to near zero without expensive software instrumentation.
  • Asymmetric Progress Tracking: For specific tasks like firmware updates, the energy overhead of local checkpointing can be eliminated entirely by shifting progress tracking from the local batteryless device to a remote distributor, as proposed by Wei et al..

The Frontier: Peripheral and Network State

While saving and restoring CPU registers and internal RAM is a solved problem, external peripherals (such as sensors, timers, and radio transceivers) present a much steeper challenge.

Peripherals are inherently stateful, but their internal configurations and volatile registers cannot be captured by a standard CPU-centric memory snapshot. Furthermore, external environments do not pause when a device loses power. If a device is interrupted mid-way through a radio transmission or a sensor reading, simply restoring the CPU registers upon wake-up will leave the peripheral in an uninitialized or desynchronized state, as discussed by Al-Hashimi et al. and Balsamo et al..

To achieve true continuity, systems must implement comprehensive state restoration. This involves capturing peripheral register configurations and explicitly reapplying them upon recovery to re-initialize external components to their exact pre-failure functional state, a method developed by Lazarescu et al..

Managing these complex, fragmented execution paths makes debugging exceptionally difficult. To address this, Bagchi et al. highlighted the adaptation of record-and-replay techniques to capture and reproduce intermittent execution traces.

The challenge of maintaining stateful external interactions during power boundaries is a recurring theme in low-power design. For example, in traditional wall-powered systems, Agarwal demonstrated the necessity of using dedicated, low-power secondary processors to maintain network presence and protocol state while the main system is asleep. In the context of intermittent computing, solving the peripheral problem means ensuring that when the device "wakes up," it can seamlessly pick up its conversation with the physical world exactly where it left off.

History & citationVersion 2 · 2026-10-04

Current · Permanent link

  1. Version 2 (latest) · 2026-10-04 · 37 papers
  2. Version 1 · 2026-10-04 · 30 papers
Cite this direction

Latest version (a living page):

@misc{lacuna_intermittent_computing_d34a4eb6,
  title = {intermittent computing},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/intermittent-computing/rdr_d34a4eb618ef4b70a9504b2e818dfd9d},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-19},
}

This exact version (version 2, frozen text):

@misc{lacuna_intermittent_computing_d34a4eb6_v2,
  title = {intermittent computing},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/intermittent-computing/rdr_d34a4eb618ef4b70a9504b2e818dfd9d/v/2},
  note = {Version 2, frozen 2026-10-04. Accessed 2026-11-19},
}

See something wrong? Report a mistake