Hardware Redundancy for Reliable Safety-Critical Computing

This direction is merged into another direction: soft error vulnerability, inactive transistor bridging. Its last version stays readable and citable here.

Version 1 of 121 papers33 conceptsfrozen 2026-10-04

In safety-critical domains like autonomous driving and space exploration, a single bit-flip caused by a cosmic ray or a power spike can be catastrophic. As we push for higher performance using standard commercial hardware, we face a fundamental tension: the high-performance chips needed for AI and sensor fusion are often more susceptible to "soft errors" than traditional, slower microcontrollers.

To bridge this gap, researchers are moving away from expensive, specialized "radiation-hardened" manufacturing. Instead, they are building resilience directly into the architecture through various forms of redundancy.

Voting for Truth: Triple Modular Redundancy

The most intuitive way to ensure a system is telling the truth is to ask three versions of it and take a majority vote. This is known as Triple Modular Redundancy (TMR). If one component fails or produces an error, the other two "outvote" it, allowing the system to continue operating without interruption.

While TMR has traditionally been used for hardware reliability, Bertil Folliot and Peter Druschel highlight that it can be applied to software servers to mitigate Byzantine failures—where components don't just crash but behave maliciously or erratically.

In modern silicon, this often takes the form of Triple-Core Lockstep (TCLS). Systems like Trikarenos and SentryCore, developed by researchers including Michael Rogenmoser, use three identical RISC-V cores executing the same instruction stream. A hardware majority voter compares their outputs in real-time. If a mismatch occurs, the system triggers a recovery routine to synchronize the cores back to a known-good state. This allows standard commercial manufacturing processes to achieve the dependability required for robotic control or automotive braking.

Lockstep and Temporal Staggering

When three cores are too expensive in terms of area and power, designers often turn to Dual Core Lockstep (DCLS). Here, two cores run the same task, and a comparison module checks for any discrepancy.

However, simple duplication has a weakness: "common-cause" failures. A single power glitch or clock jitter might affect both cores simultaneously in the exact same way, causing them to produce the same incorrect result. To prevent this, Marcel Sarraseca and Sergi Alcaide implement time-staggered execution in the SafeLS architecture. By running the "shadow" core a few clock cycles behind the primary core, the system ensures they are never in the same electrical state at the same time, making it highly unlikely that a transient fault will affect both identically.

Physical Hardening through Spatial Separation

Redundancy isn't just about adding more cores; it can happen at the level of individual transistors and signals. When a high-energy particle strikes a chip, it creates a "cloud" of charge that can affect nearby nodes—a phenomenon known as charge sharing.

To combat this, researchers use spatial separation. Guang Mao and colleagues designed a 16-transistor memory cell that interlocks transistors so that dependent nodes are physically distant. This ensures a single strike cannot flip both the storage node and its control logic.

Similarly, Guo Hong-Xia and Zhang Hong demonstrated that splitting control signals into redundant, physically separated paths prevents single event transients from triggering false logic states in flip-flops. By isolating the paths, they ensure a localized disturbance cannot overwhelm the circuit's inherent redundancy.

Efficiency through Mathematical Correlation

Traditional redundancy often requires a 2x or 3x overhead in hardware. However, Zhen Gao and Pedro Reviriego show that we can be smarter. In digital communication decimators, they exploit the mathematical correlation between adjacent filter outputs. Instead of triplicating the entire filter, they use a "duplication-with-comparison" structure on the error-checking logic itself. This achieves a 95% reduction in severe failures with only 1.5x the resources, proving that fault tolerance can be optimized by understanding the specific data being processed.

Scaling to High-Performance Computing

As we move toward autonomous vehicles, the need for raw speed is non-negotiable. Francisco J. Cazorla and his team propose the concept of a Safety Island. In this model, a small, highly reliable "island" of safety-certified hardware manages the synchronization and output verification of massive, non-certified High-Performance Computing (HPC) cores. This allows the system to benefit from the speed of modern GPUs and multicores while maintaining a rigorous safety "anchor" that detects and contains faults before they can affect the broader system.

Even in the realm of secure multi-party computation, these principles apply. The LEGO protocol by Claudio Orlandi and Jesper Buus Nielsen applies fault-tolerant design at the NAND gate level. By bundling redundant gates and using majority voting, they ensure that even if a malicious actor provides faulty components, the overall computation remains correct.

Papers in this version

History & citationVersion 1 · 2026-10-04

Merged into another direction · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_hardware_redundancy_for_reliable_safety__52090f96,
  title = {Hardware Redundancy for Reliable Safety-Critical Computing},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/hardware-redundancy-for-reliable-safety-critical-computing/rdr_52090f960e0445c2895666b899a88821},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-19},
}

This exact version (version 1, frozen text):

@misc{lacuna_hardware_redundancy_for_reliable_safety__52090f96_v1,
  title = {Hardware Redundancy for Reliable Safety-Critical Computing},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/hardware-redundancy-for-reliable-safety-critical-computing/rdr_52090f960e0445c2895666b899a88821/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-19},
}