Pseudo Linear Dynamic Byte Array for Fragmented Data Storage

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

In application server and database environments, large memory arrays with unused space cause performance issues like out-of-memory errors and excessive virtual machine thrashing during garbage collection, especially when dealing with sparse or variable-width data.

Innovation Solution

A pseudo linear dynamic byte array is used to allocate memory based on actual data size, dynamically allocating blocks and minimizing wastage by using block offsets to manage data storage and retrieval efficiently.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Quantity of substance

If large memory arrays are allocated to store data, then data storage capacity is improved, but memory wastage and system performance deteriorate

Engineering Contradiction:
Improvedata storage capacityVSAvoidmemory wastage
Core Design Contradiction:
Quantity of substanceVSLoss of energy

Solution Approach 1:

The patent divides the memory array into multiple blocks, where each block can be independently allocated and managed. This segmentation allows the system to allocate only the necessary blocks for storing actual data, avoiding the need to allocate a single large continuous array that would contain unused space. The blocks are organized in a chain structure, enabling efficient utilization of memory resources while maintaining adequate storage capacity.

Inventive Principle:
Principle #1Segmentation

2Quantity of substance

If large memory arrays are allocated to store data, then data storage capacity is improved, but system performance and reliability deteriorate due to out-of-memory errors

Engineering Contradiction:
Improvedata storage capacityVSAvoidsystem performance
Core Design Contradiction:
Quantity of substanceVSReliability

Solution Approach 1:

The patent implements a dynamic block allocation mechanism where memory blocks are allocated on-demand based on actual data insertion needs. The system maintains a pool of reusable blocks and dynamically assigns them to data storage operations. This dynamic approach prevents the system from being constrained by fixed large array allocations, reducing out-of-memory errors while improving reliability through efficient memory management.

Inventive Principle:
Principle #15Dynamics

3Quantity of substance

If large memory arrays are allocated to store data, then data storage capacity is improved, but virtual machine performance deteriorates due to excessive garbage collection thrashing

Engineering Contradiction:
Improvedata storage capacityVSAvoidvirtual machine performance
Core Design Contradiction:
Quantity of substanceVSProductivity

Solution Approach 1:

The patent implements a block reuse mechanism where memory blocks that have been emptied or are no longer needed are returned to a free pool for future reuse. This recovering approach prevents the continuous allocation and garbage collection of large memory arrays, significantly reducing virtual machine thrashing during garbage collection. The system maintains adequate storage capacity by reusing blocks rather than relying on continuous large array allocations.

Inventive Principle:
Principle #34Discarding and recovering

Data Source

PatentUS9720970B2Efficient storage and retrieval of fragmented data using pseudo linear dynamic byte array
Publication Date: 2017.08.01 ORACLE INT CORP
  • US9720970B2 patent drawing
  • US9720970B2 patent drawing
  • US9720970B2 patent drawing

AI summary

A system and method for efficient storage and retrieval of fragmented data using a pseudo linear dynamic byte array is provided. In accordance with an embodiment, the system comprises a database driver which provides access by a software application to a database. The database driver uses a dynamic byte array to enable access by the application to data in the database, including determining a size of a required data to be stored in memory, and successively allocating and copying the required data into the dynamic byte array as a succession of blocks. The data stored within the succession of blocks can then be accessed and provided to the application.