Automated API Verification via Synthesized Fragments
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Automated software verification of APIs is challenging due to their complex structure and large parameter spaces, leading to manual verification methods that are time-consuming and prone to errors, especially when dealing with realistic usage patterns and potential bugs like division by zero errors and memory leaks.
Innovation Solution
The use of automated formal methods and tools like C Bounded Model Checker (CBMC) for synthesizing verifiable program fragments based on user modules, which analyze API calling sequences and generate realistic test cases, reducing the need for manual construction and improving accuracy through abstract interpretation and realism spectrum considerations.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If automated formal methods are used for software verification, then verification accuracy and reliability are improved, but device complexity and computational requirements increase
Solution Approach 1:
The patent introduces a synthesis engine as an intermediary component that automatically generates verification fragments from user modules. This mediator translates complex verification problems into manageable fragments, reducing the direct complexity burden on the verification tool while maintaining high reliability through formal methods.
Solution Approach 2:
The verification process is segmented into distinct components: user modules describing desired behavior, a synthesis engine that generates fragments, and verification tools that analyze fragments. This segmentation allows each component to be optimized independently, reducing overall system complexity while maintaining verification accuracy.
2Device complexity
If manual verification methods are used, then device complexity is reduced, but productivity and time efficiency deteriorate
Solution Approach 1:
The synthesis engine performs self-service by automatically generating verification fragments from user module specifications without requiring manual intervention. This automation dramatically increases productivity while keeping the verification process conceptually simple through the use of high-level specifications rather than detailed verification code.
Solution Approach 2:
The system performs preliminary action by automatically generating and preparing verification fragments before the actual verification process. This pre-processing step handles the complex fragment generation, leaving the verification tool to simply analyze the prepared fragments, thus maintaining simplicity while improving speed.
3Reliability
If comprehensive test coverage is achieved through exhaustive testing, then reliability is improved, but loss of time and computational resources increase
Solution Approach 1:
The patent changes the parameter of verification approach from exhaustive concrete testing to formal verification of generated fragments. This parameter change allows the system to achieve comprehensive reliability by verifying all possible execution paths through formal methods rather than time-consuming exhaustive concrete testing.
Solution Approach 2:
The system replaces the mechanical system of exhaustive concrete testing with a formal verification approach. Instead of mechanically executing all possible test cases (which is time-consuming), the system uses formal logic to verify the generated fragments, achieving comprehensive coverage much faster.
Data Source
AI summary
Systems, methods, and software can be used to automate software verifications. In some aspects, one or more application program interface (API) call pairs are generated based on a source code of a user module that invokes an API. Each of the one or more API call pairs comprises a first API call that invokes the API followed by a second API call that invokes the API. One or more fragments are generated based on the one or more API calls pairs. Each of the one or more fragments represents an execution sequence that includes at least one of the one or more API call pairs. The one or more fragments are verified.