Virtual Widget Container Parallel Rendering
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional data visualization systems on mobile devices face significant processing resource strain as the number of widgets in a story increases, due to the need for sequential loading and rendering of all widgets, which is inefficient and resource-intensive, especially on limited-resource systems.
Innovation Solution
Implementing a background thread to acquire and prepare data for widgets, allowing parallel processing and reducing the load on the main thread, while also avoiding partial query responses and conserving memory by using lightweight rendering components and metadata preparation.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Quantity of substance
If all widgets are received and loaded one at a time in a single mobile rendering object, then memory usage is reduced, but processing time and rendering efficiency deteriorate significantly
Solution Approach 1:
The patent divides the widget rendering process into separate mobile rendering objects, allowing widgets to be rendered in parallel across multiple threads rather than sequentially in a single thread. This segmentation enables concurrent processing while managing memory usage through controlled instantiation of rendering objects.
Solution Approach 2:
The patent prepares widget data and metadata in advance on background threads before rendering is needed. By pre-processing data acquisition and preparation tasks beforehand, the main rendering thread can focus on efficient rendering without being blocked by data preparation operations, thus improving overall rendering efficiency.
2Productivity
If two mobile rendering objects are executed to render widgets in parallel, then rendering efficiency improves, but processing resource strain worsens
Solution Approach 1:
The patent dynamically manages the creation and destruction of mobile rendering objects based on workload requirements. Rendering objects are instantiated only when needed for specific widget rendering tasks and destroyed afterward, allowing the system to scale resource usage dynamically rather than maintaining a fixed number of rendering objects, thus reducing overall resource strain.
Solution Approach 2:
The patent uses lightweight copies of rendering objects for parallel widget rendering instead of creating fully independent rendering instances. By sharing common resources and state among rendering objects where possible, the system achieves parallel rendering capability while minimizing the total resource footprint.
3Device complexity
If the main thread handles all widget rendering tasks, then thread management is simplified, but processing speed and responsiveness deteriorate
Solution Approach 1:
The patent introduces a task queue as an intermediary between the main thread and background worker threads. The main thread submits rendering tasks to the queue without direct execution, while background threads pick up and execute tasks independently. This intermediary mechanism enables parallel processing to improve speed while keeping thread management relatively simple through the centralized queue interface.
Data Source
AI summary
A system includes reception of a request to execute queries associated with an interactive data visualization, building, based on the request, of all queries required by the interactive data visualization on a background thread, reception of a query response associated with each built query on the background thread, building of a final response on the background thread based on the received query responses, and rendering, on a main thread, of the interactive data visualization based on the final response.