FPGA dynamic reconfiguration can add a repair mechanism to a redundant system: rather than treating a fault as an immediate reason to replace or restart the whole design, the system can identify an affected subsystem and reconfigure that portion. In the architecture discussed here, four similar MIPS processor modules are arranged as two subsystems. Redundancy supports fault detection and continued processing, while partial reconfiguration provides a way to restore a faulty subsystem.
This approach is relevant to engineers and system designers working with embedded computing in demanding environments, where hardware faults and corrupted data can challenge dependable operation. Its central design principle is to combine redundancy with localized recovery, then assess reliability using a model of component failure and repair.
How the four-module redundant architecture works
The design divides its logic into static and reconfigurable sections. Static logic includes instruction and data memory, an error output module, and a data output selection module. The reconfigurable section contains two identical subsystems, System A and System B. Each subsystem has two MIPS processing modules and an analysis unit.
The two processors in a subsystem process the same input data. Their outputs go to the analysis unit, which checks for errors and generates output data. Its error-detection function analyzes the subsystem’s results and reports fault information externally. Its output-generation function filters, extracts, and integrates data to produce the subsystem’s output.
The error output and selection logic have related but distinct responsibilities: one produces module failure-detection signals, and the other uses fault information to control which output is selected. Together, they provide a way to detect errors and manage system output.
Why reconfigure a subsystem instead of the whole design?
A key feature of the architecture is that each subsystem acts as a reconfiguration unit. When an error is identified, the design can reconfigure the affected subsystem rather than rewriting all of the reconfigurable logic. This localized approach is intended to make recovery more efficient and avoid needlessly disturbing the other subsystem.
In a fault-tolerant design, redundancy and reconfiguration address different parts of the problem. Redundant processing provides multiple modules whose results can be analyzed; reconfiguration offers a means of repairing a faulty portion of the implementation. The system’s error-detection and output-selection logic connects those functions by identifying faults and controlling output behavior.
The design uses FPGA dynamic partial reconfiguration as the basis for this repair strategy. The source describes the system as self-test and self-repair, although it also refers to manual repair in discussing the prototype. The practical point is that recovery is organized around the faulty subsystem rather than a complete rewrite of the reconfigurable logic.
The processor modules and shared memories
Each processing module is a class MIPS processor with a control unit, register file, and arithmetic logic unit (ALU). The processor obtains instructions from instruction memory. Its control unit interprets each instruction and generates control signals; the register file stores and supplies data; and the ALU performs operations such as arithmetic, shifts, and logic. Results may be sent to data memory or used in subsequent processing.
The described processor uses 32-bit instructions in three formats: R-type, I-type, and J-type. These formats contain fields for operation codes, register identifiers, immediate values, shift amounts, or addresses, as appropriate. Instruction and data memory are part of the static logic, while the processor modules are in the reconfigurable subsystems.
Using Markov analysis to assess reliability
The system’s reliability is evaluated with a continuous-time Markov process. This type of model represents the system as a set of possible states and describes transitions between them, such as a component moving from working to failed or being restored through repair. The analysis assumes component lifetimes and repair times follow exponential distributions, allowing failure and repair behavior to be represented by rates.
In the paper’s model, λ represents a processor module’s failure rate, c represents the probability that a processing failure is detected, and μ represents the repair or reconstruction rate. These parameters help describe how faults, detection, and recovery affect the probabilities of the system occupying different states over time.
The reported simulation results show reliability increasing as the reconstruction rate μ increases. For example, the table reports R(t) values of 0.9671 when μ is 0 and 0.9991 when μ is 1. The paper presents this as evidence that faster reconstruction improves the modeled system reliability. These results reflect the model’s assumptions and should not be treated as universal performance figures for other hardware or operating conditions.
Practical implications for system designers
For engineers considering redundant FPGA-based systems, the architecture highlights several design questions:
- Define fault boundaries: Decide which logic belongs in each independently reconfigurable unit.
- Plan fault detection and output control: Specify how module errors are recognized and how the system selects or manages outputs.
- Account for repair behavior: Include the assumed detection and reconstruction rates when evaluating reliability.
- Validate the implementation: The reliability model provides an analytical assessment, but the described design was expected to be verified on an XUPV5-LX110T development board.
The practical value of four-module redundancy depends on more than the number of processors. The analysis and control logic, the scope of reconfiguration, and the repair assumptions all shape how the system responds to faults.
Conclusion
Combining four-module redundancy with FPGA dynamic reconfiguration offers a structured way to detect faults and target recovery at the subsystem level. The design pairs two MIPS processors and an analysis unit in each of two reconfigurable subsystems, supported by static memory and output-control logic. Markov analysis links reliability to failure, detection, and reconstruction behavior. For system designers, the main takeaway is to treat redundancy, fault diagnosis, and localized repair as coordinated elements of the architecture—and to validate model assumptions against the intended implementation.