Scalable Error Control Code Protocol for Dynamic Parity Adjustment
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional error control codes (ECC) like CRC32 are inflexible and not scalable, leading to inefficient data packet transmission as they consume too many bits for small packets and limit data bit length, failing to adapt to varying payload sizes.
Innovation Solution
A scalable ECC protocol that dynamically adjusts the number of parity bits based on the data packet size, using a table to generate parity bits that match the number of data bits, reducing overhead and ensuring efficient data transfer without changing the ECC processing method.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If conventional error control codes like CRC32 are used, then error detection capability is maintained, but energy consumption increases and transmission efficiency decreases due to fixed parity bit length
Solution Approach 1:
The patent applies dynamics by making the parity bit length variable rather than fixed. The ECC dynamically adjusts the number of parity bits based on the actual data payload size, transitioning from a static CRC32 approach (always 32 parity bits) to a dynamic scheme where smaller payloads use fewer parity bits. This resolves the contradiction by allowing the system to maintain error detection capability while reducing energy consumption for smaller data transmissions.
Solution Approach 2:
The patent changes the parameter of parity bit length from a fixed value (32 bits in CRC32) to a variable parameter that scales with data size. By implementing a scalable ECC where the number of parity bits is determined based on the data payload characteristics, the system can adapt error detection strength to match actual needs, reducing unnecessary energy expenditure on overhead for small packets while maintaining reliability.
2Reliability
If conventional error control codes like CRC32 are used, then error detection capability is maintained, but data transmission efficiency decreases due to fixed overhead
Solution Approach 1:
The patent implements dynamics by making the ECC overhead adaptive rather than fixed. The system dynamically calculates the appropriate parity bit length based on the data payload size, allowing smaller packets to have proportionally smaller overhead. This improves transmission efficiency by reducing the total packet size for small data transmissions while maintaining adequate error detection capability through scalable parity coverage.
Solution Approach 2:
The patent changes the overhead parameter from a fixed 32-bit parity section in CRC32 to a variable overhead that scales with data size. By implementing scalable ECC where parity bit length is determined by data characteristics, the system reduces protocol overhead for small packets, thereby improving overall data transmission efficiency and productivity.
3Reliability
If conventional error control codes like CRC32 are used, then error detection capability is maintained, but adaptability to varying payload sizes decreases
Solution Approach 1:
The patent applies dynamics by implementing an adaptive ECC system that adjusts its operation based on payload characteristics. The error detection capability dynamically scales with data size, allowing the same ECC mechanism to effectively handle both small and large packets. This resolves the contradiction by making the system versatile across different payload sizes while maintaining appropriate error detection strength for each case.
Solution Approach 2:
The patent implements universality by creating a scalable ECC framework that can handle multiple payload sizes with a single unified approach. Rather than requiring different ECC configurations for different data sizes, the scalable ECC provides a universal solution that adapts to various payload characteristics, enhancing the system's versatility and adaptability across different transmission scenarios.
Data Source
AI summary
Devices and methods may be used to append a scalable number of parity bits in a data packet that scales with a number of data bits in a payload of the data packet. The parity bits may be generated utilizing a table of entries. In some examples, each entry in the table corresponds to a number of the data bits to be included in the payload; and each column of the table may be used to generate a corresponding parity bit of the one or more parity bits.