Runtime Assembly Code Manipulation for Software Performance Evaluation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Software performance evaluation in cloud deployments is challenging due to varying operational workloads, as existing methods often require source code changes, which can introduce bugs and IP risks, and may not adequately cover unique workload characteristics, leading to service level agreement violations.
Innovation Solution
A method and system for evaluating software performance through run-time assembly code execution, where equivalent program regions are identified, marked, and manipulated to measure performance metrics without altering the source code, allowing for optimal instruction sequences to be determined under specific workloads.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If source code changes are made to enhance performance, then performance may be improved, but bugs may be introduced and intellectual property risks increase
Solution Approach 1:
The patent segments the software evaluation process into two distinct parts: the original unmodified source code and the modified assembly code. By separating these concerns, the invention allows performance testing without contaminating the original source code with potential bugs, thus maintaining reliability while enabling performance improvements through assembly-level optimizations.
Solution Approach 2:
The patent introduces assembly code as an intermediary layer between the source code and the execution environment. This intermediary allows performance enhancements to be applied at the machine code level without directly modifying the source code, thereby avoiding the introduction of bugs while still achieving performance gains.
2Measurement precision
If source code is modified for performance evaluation, then performance metrics can be measured, but intellectual property risks increase
Solution Approach 1:
The patent creates a copy of the source code in the form of assembly code. This copy allows for performance measurement and manipulation without altering the original source code, thus eliminating intellectual property risks while maintaining the ability to conduct precise performance evaluations.
Solution Approach 2:
Assembly code serves as an intermediary that enables performance measurement without direct source code modification. This intermediary layer protects intellectual property by keeping the original source code intact while still allowing for accurate performance metric collection.
3Productivity
If existing performance evaluation techniques are used, then general performance can be assessed, but unique workload characteristics are not adequately covered
Solution Approach 1:
The patent makes the performance evaluation dynamic by allowing assembly code manipulation at runtime based on specific workload characteristics. This enables the system to adapt to unique workload requirements while maintaining general performance evaluation capabilities, resolving the contradiction between broad applicability and specialized adaptation.
Data Source
AI summary
A system and method for evaluating performance of a software application. The present invention includes analyzing by one or more computing devices a plurality of program code lines of the software application stored in one or more computer databases. Further, one or more equivalent program regions within the plurality of program code lines may be identified. One or more markers in the identified one or more equivalent program regions may be inserted and stored in the one or more computer databases. Further, the plurality of program code lines may be compiled and assembled respectively to generate an executable code. The executable code may include a plurality of instructions. Further, performance metrics of the software application may be measured by manipulating the plurality of instructions based on the one or more equivalent program regions identified by the inserted one or more markers and executing the executable code.