Transient execution faults can corrupt data and intermediate results without terminating a running application. These faults may cause silent data corruption. Conventional fault-tolerance methods often depend on hardware redundancy, replicated execution, or independently developed software versions. This paper investigates an alternative based on single-version software fault tolerance. Building on prevailing research works on transient software fault tolerance, recovery, data-error recovery, and static redundancy, this study proposes an integrated single-version algorithm. The algorithm combines selective computation redundancy, data-integrity checks, assertions, program-flow monitoring, and checkpoint-based recovery. A small numerical application is used to demonstrate the design. A Python prototype is evaluated against an unprotected baseline using 10,000 integer inputs. The preliminary benchmark uses 50 timed repetitions and compares median execution times. The baseline completes in 0.359 milliseconds, while the protected implementation takes 1.451 milliseconds. This corresponds to approximately 304.3% execution-time overhead. The protected implementation also detects and recovers from a deliberately injected accumulator error in the demonstration. These measurements establish functional feasibility, not general fault coverage. The experiment is limited to a simple workload and one fault-injection pattern
This paper presents a single-version software fault-tolerance algorithm based on computation redundancy, checksum validation, assertions, program-flow monitoring, and checkpoint recovery. The design builds on the research direction established by related publications on transient software fault tolerance, data-error recovery, and static redundancy. A small Python application demonstrates the algorithm. The preliminary benchmark reports a baseline median runtime of approximately 0.359 milliseconds and a protected runtime of approximately 1.451 milliseconds. The corresponding execution-time overhead is 304.3%. The prototype also detects and recovers from a deliberately injected accumulator error. These findings establish the feasibility of the demonstration, not general fault coverage. In future, further experiments will be done to measure static code redundancy, memory overhead, detection coverage, silent data corruption, recovery success, and performance across multiple workloads and fault types. The main research opportunity is to optimize the balance between protection and overhead. Selective redundancy and validated recovery provide a practical starting point for that investigation.
References
Avizienis, A. (1985). The N-version approach to fault-tolerant software. IEEE Transactions on Software Engineering, SE-11(12), 1491–1501. Elnozahy, E. N., Alvisi, L., Wang, Y.-M., & Johnson, D. B. (2002). A survey of rollback-recovery protocols in message-passing systems. ACM Computing Surveys, 34(3), 375–408. Huang, K.-H., & Abraham, J. A. (1984). Algorithm-based fault tolerance for matrix operations. IEEE Transactions on Computers, C-33(6), 518–528. Montezanti, D., Rucci, E., De Giusti, A., Naiouf, M., Rexachs, D., & Luque, E. (2020). Soft errors detection and automatic recovery based on replication combined with different levels of checkpointing. Future Generation Computer Systems, 113, 240–254. Randell, B. (1975). System structure for software fault tolerance. IEEE Transactions on Software Engineering, SE-1(2), 220–232. Saha, G. K. (2003). Transient software fault tolerance through recovery. Ubiquity, 2003(September), Article 2. Association for Computing Machinery. Saha, G. K. (2005a). Transient software fault tolerance using single-version algorithm. Ubiquity, 2005(August). Association for Computing Machinery. Saha, G. K. (2005b). Software implemented fault tolerance through data error recovery. Ubiquity, 2005(September). Association for Computing Machinery. Saha, G. K. (2005c). Software-based fault tolerant computing. Ubiquity, 2005(November). Association for Computing Machinery. Saha, G. K. (2006a). A single-version scheme of fault tolerant computing. Journal of Computer Science and Technology, 6(1), 22–27. Saha, G. K. (2006b). A single-version algorithmic approach to fault tolerant computing using static redundancy. CLEI Electronic Journal, 9(2). Young, J. W. (1974). A first order approximation to the optimum checkpoint interval. Communications of the ACM, 17(9), 530–531.
📋 How to Cite This Paper
Goutam Kumar Saha, Dr Brij Mohan Pareek (2026). Design and Experimental Evaluation of a Single-Version Software Fault-Tolerance Algorithm for Transient Execution Errors. International Journal of Computer Science Engineering Techniques, 10(5), 398–412. ISSN: 2455-135X. DOI: https://doi.org/10.5281/zenodo.23594523
