Random Access File Management for Low Memory Devices

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Devices with limited file storage and main memory capacity, such as Web browsers and mobile computing devices, face challenges in managing and accessing large files like video and audio files, as they require random access and low memory consumption, which existing technologies struggle to provide efficiently.

Innovation Solution

A method and system for random access file storage that allows writing data chunks at arbitrary byte offsets within a file, using a file controller and memory interface to manage data blocks, reducing main memory consumption by loading only necessary blocks into memory, and utilizing native data storage facilities for efficient data access and manipulation.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Ease of operation

If the entire file is loaded into main memory for random access, then random access capability is improved, but main memory consumption increases beyond available capacity

Engineering Contradiction:
Improverandom access capabilityVSAvoidmain memory consumption
Core Design Contradiction:
Ease of operationVSQuantity of substance

Solution Approach 1:

The file is divided into multiple blocks of fixed size (e.g., 4KB each). Only the blocks that need to be accessed are loaded into main memory, while other blocks remain in persistent storage. This segmentation allows random access to file portions without loading the entire file into memory, resolving the contradiction between random access capability and memory consumption.

Inventive Principle:
Principle #1Segmentation

2Adaptability or versatility

If data is written at arbitrary byte offsets in a large file, then file modification flexibility is improved, but memory usage exceeds device capacity

Engineering Contradiction:
Improvefile modification flexibilityVSAvoidmemory usage
Core Design Contradiction:
Adaptability or versatilityVSQuantity of substance

Solution Approach 1:

The patent extracts only the necessary data blocks containing the byte offsets where writes are needed, along with a small amount of metadata, into main memory. The file controller manages these extracted blocks separately, allowing flexible write operations at arbitrary offsets without requiring the entire file to reside in memory.

Inventive Principle:
Principle #2Taking out (Extraction)

3Adaptability or versatility

If traditional file storage methods are used on devices with limited memory, then device compatibility is improved, but random access performance deteriorates

Engineering Contradiction:
Improvedevice compatibilityVSAvoidrandom access performance
Core Design Contradiction:
Adaptability or versatilityVSSpeed

Solution Approach 1:

The system dynamically loads and unloads file blocks into and from main memory based on access patterns and available memory. The file controller monitors which blocks are currently in memory and manages their lifecycle, allowing the system to adapt to different device configurations and access scenarios, maintaining both compatibility and performance.

Inventive Principle:
Principle #15Dynamics

Data Source

PatentUS10664196B2Random access file management
Publication Date: 2020.05.26 MICROSOFT CLIPCHAMP HOLDINGS PTY LTD
  • US10664196B2 patent drawing
  • US10664196B2 patent drawing

AI summary

A method for modifying a file having a file size exceeding a size of available main memory, the file arranged in one or more existing data blocks, by writing an array of new data to the file at a file offset to replace a portion of the existing data of the file. The method including determining one or more target data blocks of the file which contain data to be replaced, considering a size of the array of new data, the block size of the file and the file offset within the file, retrieving at least one of the target data blocks from the file, creating at least one new data block comprised of at least one of the one or more write byte arrays, and writing the new data block to the file at the location of the target data blocks.