Distributed Software Verification Parallelization via Path Conditions
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional software testing methods fail to uncover hard, corner-case bugs, and existing formal verification techniques lack efficient parallelization across multiple computer entities due to inadequate load balancing.
Innovation Solution
A method for software verification that determines initialization and termination path conditions to efficiently initialize software verification jobs on computing nodes, using a distributed computing system with scheduler and worker nodes to dynamically and intelligently balance loads, thereby optimizing symbolic execution and bug detection.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If conventional software testing methods are used, then the testing process is simple and fast, but hard and corner-case bugs cannot be uncovered
Solution Approach 1:
The patent replaces conventional mechanical testing approaches with formal methods and symbolic execution. The system uses a symbolic execution engine that operates on abstract program representations rather than concrete test cases, enabling thorough exploration of all possible execution paths including hard and corner-case scenarios that conventional testing misses.
Solution Approach 2:
The patent changes the fundamental parameters of software verification by transitioning from concrete input data to symbolic representations. The system maintains symbolic expressions throughout execution, allowing infinite input space to be represented and explored systematically, thereby uncovering bugs that require exhaustive search beyond what conventional finite testing can achieve.
2Reliability
If formal methods for software verification are applied, then hard and corner-case bugs can be uncovered, but parallelization across multiple computer entities is inefficient due to inadequate load balancing
Solution Approach 1:
The patent segments the software verification task into independent units called verification jobs, each representing a specific code region or function. These segmented jobs can be distributed across multiple computing entities, allowing parallel execution while maintaining proper load balancing through the scheduler that assigns jobs based on computational complexity and resource availability.
Solution Approach 2:
The patent implements dynamic load balancing where the scheduler continuously monitors the status of verification jobs and computing entities. The system dynamically adjusts job assignments based on real-time execution progress, ensuring optimal distribution of computational workload and maximizing parallelization efficiency across the distributed computing environment.
3Productivity
If symbolic execution is parallelized across multiple computer entities, then verification speed increases, but load balancing becomes complex and initialization overhead increases
Solution Approach 1:
The patent performs preliminary actions by pre-computing and storing path conditions for verification jobs before distribution. Each job includes its initialization path condition, allowing computing entities to quickly resume verification from the exact state where they left off, eliminating the need for complex initialization procedures during parallel execution and reducing overall system complexity.
Solution Approach 2:
The patent introduces a scheduler as an intermediary component that manages the complexity of load balancing. The scheduler acts as a mediator between the verification engine and computing entities, handling job assignment, progress tracking, and coordination. This intermediary abstraction layer simplifies the overall system architecture by centralizing the complex load balancing logic in a dedicated component.
4Loss of time
If path conditions are stored and reused for job initialization, then initialization time is reduced, but memory requirements increase
Solution Approach 1:
The patent applies local quality by storing and reusing path conditions only at the granular level of individual verification jobs rather than globally. Each job maintains its own path condition history, allowing efficient reuse for initialization while limiting memory consumption to only the necessary path conditions for currently active and recently completed jobs, rather than retaining all historical path conditions system-wide.
Data Source
AI summary
A method for verifying software includes determining an initialization path condition of a received software verification job, determining a termination path condition of a computing node, and initializing the execution of the received software verification job on the computing node based on the initialization path condition and the termination path condition. The initialization path condition includes a sequence of program predicates for reaching a starting state of software to be verified. The received software verification job includes an indication of a portion of the software to be verified. The termination path condition includes an indication of the last state reached during the execution of a previous software verification job on the computing node. The computing node is assigned to execute the received software verification job.