Immutable Display Graph for Thread-Safe UI Rendering

Resolve Bottlenecks,
Find Innovative SolutionsGenerate Solutions

Solution Overview

Problem

Existing mechanisms for generating and rendering user interfaces on devices with limited processing resources face challenges in achieving efficient processing, graphics presentation, and animation while maintaining simplicity and correctness, often leading to software faults and overhead due to data sharing and synchronization issues with multiple threads.

Innovation Solution

The implementation of an immutable display graph that allows for efficient caching and rendering, with a presentation layer that splits user interface display into two stages: construction and rendering, enabling sharing among multiple threads and re-use of immutable portions, and using paint variables for time-varying components and animation, ensuring thread safety and efficient memory use.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Productivity

If multiple threads are used to handle user interface operations, then parallel processing capability is improved, but data sharing and synchronization overhead increases

Engineering Contradiction:

Improveparallel processing capabilityVSAvoiddata sharing and synchronization overhead

Core Design Contradiction:

ProductivityVSDevice complexity

Solution Approach 1:

The user interface rendering process is segmented into two distinct phases: a construction phase where the display graph is built, and a rendering phase where the graph is rendered to the screen. This segmentation allows different threads to work on different phases independently, eliminating the need for complex synchronization while maintaining parallel processing capability.

Inventive Principle:

Principle #1Segmentation

Solution Approach 2:

The display graph is created as an immutable data structure that can be safely copied and shared across multiple threads without requiring synchronization. Each thread receives its own copy or reference to the immutable graph, eliminating data sharing conflicts while enabling parallel rendering operations.

Inventive Principle:

Principle #26Copying

2Productivity

If multiple threads are used for user interface operations, then processing throughput is improved, but software faults increase due to synchronization issues

Engineering Contradiction:

Improveprocessing throughputVSAvoidsoftware fault rate

Core Design Contradiction:

ProductivityVSReliability

Solution Approach 1:

Instead of making the display graph mutable and requiring synchronization to protect it, the patent inverts the approach by making the display graph immutable. This inversion eliminates the need for synchronization mechanisms, thereby reducing software faults while maintaining high processing throughput through parallel thread execution.

Inventive Principle:

Principle #13The other way round (Inversion)

3Reliability

If immutable display graph is used, then thread safety and memory efficiency are improved, but flexibility for dynamic updates decreases

Engineering Contradiction:

Improvethread safetyVSAvoidflexibility for dynamic updates

Core Design Contradiction:

ReliabilityVSAdaptability or versatility

Solution Approach 1:

All dynamic updates and modifications to the display graph are performed in advance during the construction phase, before the rendering phase begins. This preliminary action allows the immutable graph to be fully prepared with all necessary dynamic content, eliminating the need for runtime modifications while maintaining thread safety and memory efficiency.

Inventive Principle:

Principle #10Preliminary action

Data Source

PatentUS8477136B2Functional presentation layer in a lightweight client architecture

Publication Date: 2013.07.02 ADEIA MEDIA HOLDINGS INC

AI summary

A device generates an immutable display graph with leaves of the display graph representing low-level graphical operations such as drawings lines or a bitmap and nodes of the display graph representing translation and clipping. Because the display graph is immutable, it can be cached, shared, and rendered quickly. The structure of the display remains fixed, but elements such as rectangle fill, text position, clipping area, translation, and image location, remain time varying and can change without affecting the structure of the display.