Abstract Code Execution Timeline for Video Game Profiling
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional software visualization techniques become less effective with the increasing complexity of software and hardware, particularly in multi-core processing environments where concurrent functions process millions of instructions per second, making it difficult to understand and visualize the execution of software programs.
Innovation Solution
A system and method for generating an abstract code execution timeline by capturing statistical sampling profiles and converting them into chronological and hierarchical representations, allowing for the selection of representative functions and their ordering to create a readable timeline that summarizes program execution within a single time period, referred to as 'Story Mode'.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Measurement precision
If conventional software visualization techniques are used to track concurrent functions in multi-core processing environments, then complete execution data can be captured, but the complexity of visualizing and understanding the execution becomes overwhelming
Solution Approach 1:
The patent extracts only the most relevant execution information from the complete concurrent function data. It identifies and extracts key functions, their call relationships, and timing information, while filtering out redundant details. This extraction process transforms the overwhelming complete execution data into a manageable subset that preserves essential execution semantics for visualization purposes.
Solution Approach 2:
The patent segments the complex execution data into distinct hierarchical levels: main functions, sub-functions, and nested call relationships. Each segment is processed and visualized separately at appropriate detail levels, allowing the system to manage complexity by dividing the monolithic execution trace into organized, hierarchical segments that can be progressively explored.
2Loss of information
If detailed execution traces of all concurrent functions are visualized, then complete program behavior can be understood, but the readability and comprehensibility of the timeline deteriorates
Solution Approach 1:
The patent implements dynamic adjustment of visualization detail levels based on user interaction and context. The timeline can be viewed at different zoom levels, where higher levels show only key main functions for overall understanding, while lower levels reveal detailed sub-function calls and nested relationships. This dynamic scaling allows users to navigate from big-picture understanding to detailed analysis as needed.
Solution Approach 2:
The patent applies partial action by selectively visualizing only the most significant portions of execution traces. Instead of displaying every function call equally, it emphasizes key functions that have substantial impact on program behavior, while still preserving the ability to access complete information when needed. This selective emphasis maintains readability while preventing information loss.
3Measurement precision
If statistical sampling profiles are captured for all functions during program execution, then comprehensive execution data is obtained, but the processing time and computational resources increase
Solution Approach 1:
The patent applies partial action by capturing statistical sampling profiles selectively rather than for all functions uniformly. It focuses sampling efforts on key functions identified as having significant execution impact, while using less intensive monitoring for less critical functions. This selective profiling approach maintains comprehensive understanding of program behavior while reducing overall processing overhead.
Solution Approach 2:
The patent segments the profiling process into multiple passes with different sampling intensities. Initial profiling identifies key functions, followed by targeted detailed profiling of those specific functions, while using coarser sampling for other functions. This segmented approach distributes processing load across different time periods and function sets, reducing peak computational requirements while maintaining overall profiling accuracy.
Data Source
AI summary
The present technology is directed to a non-limiting system and method for generating an abstract code execution timeline from repetitive programs, such as video games and simulations. As a non-limiting example, a statistical sampling profile is first taken of the running program, and then the data is converted into several representations. By selecting representative functions based on sampling frequency and call tree hierarchy and then sorting those functions chronologically and hierarchically, an abstract code execution timeline can be generated that summarizes execution within a single repetitive time period, such as a video frame. This timeline is called “Story Mode” since it tells a story of how the program executes over the course of a frame. This abstract code execution timeline can then be used to facilitate program comprehension, primarily for the purposes of modifying the code to improve execution speed.