Graph-Based Application Patching for Smaller Network Updates

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Existing application update processes require significant storage space and network utilization due to the high density of unstable intra-file references, especially in data-limited networks, leading to inefficiencies and increased costs.

Innovation Solution

A computing system generates directed acyclic graphs for current and prior application versions, pairs matching nodes, and applies encoded step functions to minimize byte differences, using a patching algorithm to generate a mutated prior version that closely matches the current version, reducing the update size and network requirements.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Ease of manufacture

If traditional patching algorithms are used to update applications, then the update process is simple and straightforward, but the update size becomes large and network utilization increases significantly

Engineering Contradiction:
Improvesimplicity of update processVSAvoidupdate size
Core Design Contradiction:
Ease of manufactureVSQuantity of substance

Solution Approach 1:

The patent segments the application into a prior version and a current version, then uses graph-based reference tracking to identify only the specific portions that need updating. This segmentation allows the system to create targeted patches that update only necessary references rather than transferring the entire application, thereby reducing update size while maintaining process simplicity.

Inventive Principle:
Principle #1Segmentation

Solution Approach 2:

The patent introduces graph data structures as intermediaries to represent application references and their relationships. These graphs serve as a mediator between the patching algorithm and the actual application code, enabling intelligent matching of references between versions and facilitating precise, minimal updates without requiring transfer of unnecessary data.

Inventive Principle:
Principle #24Intermediary (Mediator)

2Reliability

If the entire application is downloaded for updates, then all references are ensured to be updated, but storage space requirements increase significantly

Engineering Contradiction:
Improvecompleteness of updateVSAvoidstorage space
Core Design Contradiction:
ReliabilityVSVolume of stationary object

Solution Approach 1:

The patent extracts only the necessary reference information from the application graphs to create the patch. By identifying and extracting only the specific references that differ between versions (through graph comparison and matching), the system creates a minimal patch that contains only the essential update data, reducing storage requirements while ensuring complete and accurate updates.

Inventive Principle:
Principle #2Taking out (Extraction)

Solution Approach 2:

The patent discards redundant reference information that remains unchanged between versions, retaining only the necessary differences in the patch. This selective retention approach ensures that unchanged references are not stored in the patch, reducing storage space while maintaining the reliability of the update through precise recovery of only necessary changes.

Inventive Principle:
Principle #34Discarding and recovering

3Quantity of substance

If compression is used to reduce patch size, then network utilization decreases, but decompression complexity and potential data loss increase

Engineering Contradiction:
Improvepatch sizeVSAvoiddecompression complexity
Core Design Contradiction:
Quantity of substanceVSDevice complexity

Solution Approach 1:

The patent applies parameter changes through graph-based reference matching and encoding, transforming the patch representation to minimize size without relying on heavy compression. By changing how references are represented and matched between versions, the system achieves size reduction through intelligent encoding rather than traditional compression, avoiding decompression complexity while maintaining data integrity.

Inventive Principle:
Principle #35Parameter changes

4Quantity of substance

If graph-based reference matching is applied to minimize updates, then update size decreases significantly, but processing time and computational complexity increase

Engineering Contradiction:
Improveupdate sizeVSAvoidprocessing time
Core Design Contradiction:
Quantity of substanceVSLoss of time

Solution Approach 1:

The patent performs preliminary graph generation and reference extraction actions during the patch creation phase. By pre-processing the application structures into graphs and identifying references in advance, the system prepares matching information that can be efficiently applied during updates, reducing real-time processing time while achieving minimal update sizes through comprehensive reference analysis.

Inventive Principle:
Principle #10Preliminary action

Data Source

PatentUS20250217134A1Software application patching
Publication Date: 2025.07.03 GOOGLE LLC
  • US20250217134A1 patent drawing
  • US20250217134A1 patent drawing
  • US20250217134A1 patent drawing

AI summary

Responsive to determining that a current version of an application is different from a prior version of the application installed at a computing device, a computing system generates a first graph for the current version and a second graph for the prior version. The first and second graphs include nodes indicative of data structures and edges indicative of references. The computing system pairs, using an algorithm, uniquely matching nodes between the first graph and the second graph. The algorithm is configured to iteratively hash the first graph and the second graph, and a set of unpaired nodes are updated incrementally with hashes of the paired uniquely matching nodes. The computing system generates a control file including encoded step functions based on edges associated with the set of unpaired nodes. The computing system generates, using the encoded step functions included in the control file, a mutated prior version of the application.