Software Self-Healing via Rescue Point Recovery
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional techniques are inadequate for eliminating all software programming errors, leading to unintended behavior, crashes, and security vulnerabilities, especially in high-performance and high-availability applications, necessitating a reactive and automated self-healing mechanism.
Innovation Solution
The implementation of a method that detects fault conditions during software execution, restores the application to a previous 'rescue point', and forces a subroutine to return to its caller, using fault monitors, rescue point discovery, and patch generation to prevent further execution and propagate error values, enabling the software to recover from faults.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If conventional software development strategies and static analysis tools are used to eliminate bugs, then software reliability is improved, but it is impossible to eliminate all bugs due to software complexity
Solution Approach 1:
The patent applies preliminary action by establishing rescue points and recording execution states before faults occur. The system proactively sets up recovery mechanisms during normal execution, so when a fault is detected, the application can immediately restore to a previous known good state without requiring complex bug analysis or manual intervention.
Solution Approach 2:
The patent implements self-service through automated fault detection and self-healing mechanisms. The system monitors its own execution state, detects faults automatically, and restores itself to previous working states without external intervention. This eliminates the need for conventional manual debugging and reduces dependency on complex analysis tools.
2Reliability
If a server application crashes upon receiving certain inputs, then the fault is exposed, but denial-of-service occurs to clients until the server is restarted, resulting in loss of time
Solution Approach 1:
The system performs preliminary action by recording execution states at rescue points before faults occur. When a crash is detected, the application immediately restores to a previously recorded state, avoiding downtime. This eliminates the need for server restarts and maintains continuous service to clients.
Solution Approach 2:
The application implements self-service by automatically detecting faults and restoring itself without external intervention. The system monitors its own execution, detects crashes, and performs self-healing by restoring to previous states, thereby eliminating denial-of-service conditions and avoiding time loss.
3Reliability
If the software application restores execution to a previous point and forces a subroutine to forego further execution, then the application recovers from faults, but the subroutine does not complete its intended function
Solution Approach 1:
The patent applies beforehand cushioning by recording return values and calling context information before subroutines execute. When a fault occurs and the subroutine is forced to forego execution, the system uses the pre-recorded information to determine appropriate return values, cushioning the impact of the incomplete execution and maintaining application reliability.
Solution Approach 2:
The system implements feedback by recording and utilizing calling context information and return values. When a subroutine cannot complete due to fault recovery, the system uses feedback from previously recorded execution states to determine appropriate return values, ensuring the application maintains correct behavior despite the subroutine not completing its intended function.
Data Source
AI summary
Methods, systems, and media for enabling a software application to recover from a fault condition, and for protecting a software application from a fault condition, are provided. In some embodiments, methods include detecting a fault condition during execution of the software application, restoring execution of the software application to a previous point of execution, the previous point of execution occurring during execution of a first subroutine in the software application, and forcing the first subroutine to forego further execution and return to a caller of the first subroutine.