Software Update Chunking for Memory-Constrained Devices

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Existing software updating methods face challenges in devices with tight memory constraints, as they require storing both the current and new software versions simultaneously, which is not feasible in environments with limited RAM or flash memory, leading to inefficiencies and high memory footprints.

Innovation Solution

The solution involves using a compressed patch file approach that allows updating the device block by block, eliminating the need to store both software versions simultaneously by overwriting current software portions with updated ones, and dynamically selecting the type and size of data chunks based on the target device's memory and CPU capacity.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Reliability

If traditional A/B update method is used to transfer complete software update objects, then update reliability is improved, but memory requirements increase significantly

Engineering Contradiction:
Improveupdate reliabilityVSAvoidmemory requirements
Core Design Contradiction:
ReliabilityVSQuantity of substance

Solution Approach 1:

The patent divides the complete software update object into multiple smaller data chunks that can be processed sequentially. This segmentation allows the system to update software in portions rather than requiring the entire updated software object to be stored in memory simultaneously, thus reducing memory requirements while maintaining update reliability through progressive application of chunks.

Inventive Principle:
Principle #1Segmentation

Solution Approach 2:

The patent extracts only the necessary differences (delta encoding) between the current and updated software objects, rather than transferring the complete updated software. By taking out only the change portions and applying them incrementally, the system reduces the amount of data that needs to be stored in memory during the update process.

Inventive Principle:
Principle #2Taking out (Extraction)

2Quantity of substance

If compressed patch files are used to reduce memory usage, then memory requirements are reduced, but processing complexity increases

Engineering Contradiction:
Improvememory requirementsVSAvoidprocessing complexity
Core Design Contradiction:
Quantity of substanceVSDevice complexity

Solution Approach 1:

The patent dynamically adjusts compression parameters and chunk sizes based on the target device's memory capacity and processing capabilities. By adapting these parameters to match the device's constraints, the system achieves effective compression and reduced memory usage without overwhelming processing complexity that would arise from using fixed, overly aggressive compression settings.

Inventive Principle:
Principle #35Parameter changes

3Loss of substance

If delta encoding is used to compress update files, then compression efficiency is improved, but memory footprint increases due to algorithm requirements

Engineering Contradiction:
Improvecompression efficiencyVSAvoidmemory footprint
Core Design Contradiction:
Loss of substanceVSQuantity of substance

Solution Approach 1:

The patent applies delta encoding selectively and partially - only to the portions of the software that have changed, rather than encoding the entire software image. This partial application of compression achieves good compression efficiency for the actual update data while minimizing the memory footprint required for the encoding algorithm and intermediate data structures.

Inventive Principle:
Principle #16Partial or excessive action

Data Source

PatentEP3680773B1System and method for updating a computing device
Publication Date: 2023.08.02 PLAXIDITYX LTD
  • EP3680773B1 patent drawingFigure 1
  • EP3680773B1 patent drawingFigure 2A
  • EP3680773B1 patent drawingFigure 2B

AI summary

A system and method for updating a target device may include generating a first update object usable for creating a first portion of an updated software object based on a current software object, producing a modified software object based on to the update object and based on the current software; and generating a second update object usable for producing a second portion of the updated software object based on the modified software object. The number of update objects that can be produced based on the current software object may be determined based on a size of a lag buffer in a memory of the target device.