Programmable ECC Engines for Flexible Memory Error Correction
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional Error Correction Code (ECC) memory modules have fixed ECC implementations that cannot be changed, limiting flexibility and requiring manufacturers to choose a compromise between error correction and performance that may not adapt to future use cases, and they must match the ECC implementation with the host, which can be proprietary and not easily disclosed.
Innovation Solution
Implementing programmable ECC engines in memory modules that can be programmed by a host with specific ECC implementations, allowing secure storage and reconfiguration without revealing proprietary information to memory vendors, providing flexibility in choosing ECC algorithms and switching between them as needed.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If a fixed ECC implementation is designed into the memory module logic, then the error correction capability is ensured, but the adaptability to different hosts and use cases is reduced
Solution Approach 1:
The ECC implementation is changed from static (fixed in logic) to dynamic (programmable). The memory module contains a programmable ECC engine that can be configured with different ECC algorithms and parameters through instructions provided by the host, allowing the same hardware to adapt to different error correction requirements of various hosts and applications.
Solution Approach 2:
The ECC parameters (algorithm type, code rate, protection level) are made changeable through programming. Instead of being fixed during manufacturing, the ECC engine can receive configuration instructions that modify its operational parameters, enabling adaptation to different hosts' proprietary ECC implementations without changing the physical hardware.
2Ease of manufacture
If the ECC implementation is fixed in the memory module, then the manufacturing process is simplified, but the host designer cannot use proprietary ECC implementations without disclosing information to the memory vendor
Solution Approach 1:
The system is segmented into the memory module hardware (which provides the ECC engine platform) and the ECC implementation logic (which is provided separately as instructions by the host). This separation allows the memory vendor to manufacture a generic programmable platform without knowing the specific proprietary ECC algorithms, while the host designer retains full control over their proprietary implementation details.
Solution Approach 2:
The programmable ECC engine acts as an intermediary between the host's proprietary ECC logic and the memory module's hardware implementation. The host provides ECC instructions as a medium that configures the engine, allowing proprietary algorithms to be implemented without directly exposing the memory module's internal fixed logic to the host designer.
3Productivity
If a compromise ECC implementation is chosen during manufacturing, then the device can be produced, but it cannot be optimized for future use cases
Solution Approach 1:
The memory module is pre-configured with a programmable ECC engine framework during manufacturing, but the specific ECC implementation is left uncommitted. This preliminary setup allows rapid deployment of different ECC algorithms later through software instructions, enabling optimization for future use cases without requiring new hardware manufacturing cycles.
Data Source
AI summary
A memory module includes one or more programmable ECC engines that may be programed by a host processing element with a particular ECC implementation. As used herein, the term “ECC implementation” refers to ECC functionality for performing error detection and subsequent processing, for example using the results of the error detection to perform error correction and to encode corrupted data that cannot be corrected, etc. The approach allows an SoC designer or company to program and reprogram ECC engines in memory modules in a secure manner without having to disclose the particular ECC implementations used by the ECC engines to memory vendors or third parties.