Coroutine-Thread Interface Switching for Profiling Issue Localization
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing technologies face challenges in efficiently locating problematic coroutines/threads due to the short life cycle of coroutines and the overwhelming amount of profiling information generated, making it difficult to identify and analyze issues in depth.
Innovation Solution
An interface display method that allows quick switching between coroutine and thread interfaces, providing detailed running information at different layers (user and kernel modes) to facilitate the identification and localization of problematic coroutines/threads.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If numerous coroutines are generated to improve service performance, then computing power utilization is improved, but the complexity of locating problematic coroutines increases
Solution Approach 1:
The patent segments the coroutine information display into multiple hierarchical levels: coroutine level details, thread level details, and process level details. This segmentation allows users to navigate through the complex system by focusing on one level at a time, reducing the cognitive load when locating problematic coroutines among numerous generated coroutines.
Solution Approach 2:
The patent introduces a new dimensional approach by adding thread-level and process-level information as additional layers of abstraction. Instead of only displaying coroutine-level information, the system provides a multi-dimensional view that includes thread context and process context, enabling users to locate problematic coroutines more efficiently by examining different dimensions of the system hierarchy.
2Measurement precision
If detailed profiling information is collected to analyze coroutine performance, then measurement precision is improved, but the quantity of information to process increases
Solution Approach 1:
The patent extracts and highlights only the most critical information from the extensive profiling data. By selectively displaying key metrics such as execution time, CPU usage, and state transitions at different hierarchical levels, the system reduces the quantity of information users must process while maintaining measurement precision for performance analysis.
Solution Approach 2:
The patent implements partial action by providing summarized statistics and key metrics rather than displaying all raw profiling data. The system presents essential information at each hierarchical level (coroutine, thread, process) that is sufficient for performance analysis without overwhelming users with excessive detailed data.
3Speed
If coroutine life cycle is shortened to improve responsiveness, then system responsiveness is improved, but the difficulty of tracking problematic coroutines increases
Solution Approach 1:
The patent implements feedback mechanisms that provide real-time information about coroutine state transitions and execution status. By continuously updating the display with current coroutine information and enabling users to filter by state (e.g., running, blocked, finished), the system helps users track problematic coroutines even though their life cycles are short and responsive.
Data Source
Figure 1~2
Figure 3~4A
Figure 4B~5A
AI summary
The present disclosure provides an interface display method, which may be applied to a scenario such as coroutine/thread tuning. The method includes: displaying a first interface; and displaying a second interface in response to a first operation of a user on the first interface, where the first interface includes first running information of at least one coroutine, and the second interface includes second running information of a first coroutine on a thread among the at least one coroutine; or the first interface includes the second running information of the first coroutine on the thread among the at least one coroutine, and the second interface includes the first running information of the at least one coroutine. That is, quick switching/jumping between a coroutine interface and a thread interface for display can be implemented through the first operation of the user, so that the user can identify and locate a problematic coroutine/thread in depth at different layers (for example, in a user mode and a kernel mode).