Hardware Lossless Compression Using Processing String Partitioning

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Existing lossless data compression/decompression algorithms require data analysis or pre-processing, making them less suitable for hardware implementation, whereas the described technique compresses data without analysis, enabling seamless hardware implementation by partitioning input data into processing strings and compressing them independently.

Innovation Solution

The algorithm serially partitions the input data into sequential Processing Strings (PS) based on a fixed bit pattern delimiter or a set limit, compressing each PS individually and in pairs, allowing for unlimited cycles without data loss, and can be efficiently implemented in hardware using pipelined digital circuitry.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Ease of manufacture

If existing lossless compression algorithms are used, then data compression is achieved, but data analysis or pre-processing is required which makes hardware implementation difficult

Engineering Contradiction:
Improvehardware implementation suitabilityVSAvoiddata analysis requirement
Core Design Contradiction:
Ease of manufactureVSDevice complexity

Solution Approach 1:

The input data stream is segmented into fixed-length Processing Strings (PS) of 32 bits each. This segmentation eliminates the need for complex data analysis by processing data in uniform, predetermined blocks that can be directly fed into hardware circuits without preprocessing or adaptive decision-making logic.

Inventive Principle:
Principle #1Segmentation

2Productivity

If data is processed in fixed processing strings, then hardware implementation becomes feasible, but processing throughput must be optimized

Engineering Contradiction:
Improveprocessing throughputVSAvoidpipelined circuitry requirement
Core Design Contradiction:
ProductivityVSDevice complexity

Solution Approach 1:

The system performs preliminary actions by pre-defining the Processing String format (32 bits) and the compression lookup tables before runtime. This allows the hardware to operate in a purely combinational logic mode during compression, where each PS is independently and immediately processed without dynamic analysis or stateful memory operations, thereby maximizing throughput.

Inventive Principle:
Principle #10Preliminary action

3Speed

If compression is performed on each processing string individually, then processing speed increases, but compression ratio may be limited

Engineering Contradiction:
Improvecompression speedVSAvoidcompression efficiency
Core Design Contradiction:
SpeedVSLoss of information

Solution Approach 1:

Adjacent Processing Strings are merged into pairs for compression processing. This allows the hardware to exploit patterns and redundancies across string boundaries while maintaining the speed benefits of fixed-block processing. The pairing strategy enables better compression ratios by capturing inter-string correlations without requiring complex multi-string analysis.

Inventive Principle:
Principle #5Merging (Combining)

Data Source

PatentUS11677416B2Hardware implementable data compression/decompression algorithm
Publication Date: 2023.06.13 SECAREANU RADU MIRCEA
  • US11677416B2 patent drawing
  • US11677416B2 patent drawing
  • US11677416B2 patent drawing

AI summary

A hardware implementable lossless data compression decompression algorithm is disclosed, where the input data string is described in term of consecutive groups of alternating same type bits, where one of these groups of same type bits is defined as a preferred group with the other groups having either lower or higher number of same type bits, where the data string is partitioned into variable length processing strings where the variable length is determined by the occurrence of the preferred group or of a determined number of bits consisting of groups of lower number of same type bits, where these variable length processing strings are processed function of the configuration and content of each processing string only, where consecutive processing strings are additionally processed based on their content only, where processing is performed in a loop until a certain target performance is achieved, where processing is done without any data analysis, and where no negative compression gain is achieved for any content of an input string.