High-reliability storage chip data read-write verification system and method

Abstract

The invention belongs to the technical field of data processing, and discloses a high-reliability storage chip data read-write verification system and method. Comprising the steps of collecting sensor data in real time, maintaining a sliding window, judging a chip environment state based on environment priori knowledge, outputting an environment label and recording the environment label to a metadata log; judging whether the chip environment state of the data to be written is normal or not, if so, using normal writing, and if not, identifying the specific environment state type, dynamically adjusting the redundancy proportion, the interlocking storage structure and the self-adaptive strategy, and executing the corresponding writing process; calculating a self-refreshing interval according to the environment label, performing timing triggering, scanning a dormant block, reading and correcting errors, and then rewriting a refreshed update log; and responding to a reading request, loading blocks from the storage partitions, then reading an environment label, selecting a corresponding strategy, firstly using progressive decoding, if the decoding fails, carrying out self-healing repair, and then outputting a recovery report, thereby realizing high-reliability storage chip data read-write verification.

Description

Technical Field

[0001] This invention relates to the field of data processing technology, and more specifically, to a high-reliability memory chip data read / write verification system and method. Background Technology

[0002] The essence of data read / write verification is to ensure the integrity and accuracy of data (adding a check code when writing and verifying and correcting when reading). High-reliability storage chip data read / write verification systems face great challenges in extreme environments. This difficulty stems directly from the physical extremes of the scenario (such as high temperature, impact, and water immersion), which can significantly increase the error rate of storage chips (such as eMMC NAND flash memory) and cause traditional verification mechanisms to fail.

[0003] Chips are susceptible to bit flips, data block corruption, or read / write channel failures under conditions of high temperature, deep water immersion, high impact, vibration, and compression. The read / write verification process typically consists of three stages: writing, storing, and reading. When data is input, the writing process may be interrupted under vibration / high temperature, resulting in incomplete checksums. Under extreme conditions, unstable chip programming voltage can cause "weak writes." During post-disaster recovery, the system reads the data and compares the checksums. If there are too many errors, standard verification can only detect but not correct them, leading to data loss or misjudgment.

[0004] Error detection / correction directly affects the success rate of verification. If errors cannot be corrected, the system cannot provide reliable data. The verification system may misjudge or fail to correct errors, resulting in the loss of accident data and the inability to restore the truth (such as whether the driver or the vehicle's intelligent driving system had control), which affects the clarification of legal responsibilities and the improvement of the vehicle.

[0005] Based on the above problems, a high-reliability data read / write verification method for memory chips is proposed. Summary of the Invention

[0006] To overcome the aforementioned deficiencies of the prior art and to achieve the above objectives, the present invention provides the following technical solution: a high-reliability memory chip data read / write verification system, comprising: Multimodal environment perception module: Real-time acquisition of sensor data, maintenance of a sliding window, judgment of chip environment status based on prior environmental knowledge, output of environment labels and recording to metadata log; Write module: Used to determine whether the chip environment status of the data to be written is normal. If it is normal, normal writing is used. If it is abnormal, the specific environment status type is identified, and the redundancy ratio, interlocking storage structure and adaptive strategy are dynamically adjusted to execute the corresponding writing process. Storage module: Calculates the self-refresh interval based on environment tags, triggers it periodically, scans the dormant block, reads and corrects errors, and then rewrites the update log after refresh; Read module: Used to respond to read requests, load blocks from storage partitions, read environment tags, select the corresponding strategy, first use progressive decoding, and if it fails, perform self-healing repair, and then output a recovery report.

[0007] Preferably, the method for real-time acquisition of sensor data, maintenance of a sliding window, determination of the chip environment state based on prior environmental knowledge, output of environment labels, and recording to the metadata log includes: Sensor data includes temperature, vibration intensity, pressure, humidity, and acceleration, and is maintained within a sliding window. For the currently collected data, a check is performed based on the safety values ​​in the prior knowledge of the environment, and the overall performance of the data is calculated; If the overall performance is not lower than expected and does not match any of the high-risk environment types in the prior knowledge of the environment, then the environment status of the chip is determined to be non-hazardous, and the environment label {normal_confidence 100%} is output. If the overall performance exceeds expectations or matches at least one high-risk environment type in the prior knowledge of the environment, the chip's environment state is determined to be dangerous. The specific environment state type is determined based on the data sequence within the sliding window, and the environment label {abnormal_environment state type-()_confidence} is output and then recorded in the metadata log.

[0008] Preferably, the prior environmental knowledge includes: High-risk environment types are predefined, including high-temperature environment, high-vibration environment, high-impact environment, deep-water immersion environment, and extrusion environment. The criteria for each type are as follows: when the chip temperature exceeds the temperature safety value and the duration exceeds the time safety limit, it is classified as a high-temperature environment; when the chip vibration intensity exceeds the vibration safety value and the duration exceeds the time safety limit, it is classified as a high-vibration environment; when the chip acceleration peak exceeds the acceleration safety value, it is classified as a high-impact environment; when the chip pressure exceeds the pressure safety value or the humidity exceeds the moisture safety value and the duration exceeds the time safety limit, it is classified as a deep-water immersion environment; and when the chip pressure exceeds the pressure safety value and the duration exceeds the time safety limit, it is classified as an extrusion environment. The design of chips based on high-risk environment types includes three environmental states: single environment, mixed environment, and sequential environment. A single environment means that the chip is in only one type of high-risk environment. A mixed environment means that the chip is in more than one type of high-risk environment at the same time without any order of occurrence. A sequential environment means that the chip is in more than one type of high-risk environment with a clear time sequence of occurrence.

[0009] Preferably, determining whether the chip environment status of the data to be written is normal includes: Read the environment tag of the data to be written. If it is recognized as normal, the writing process is as follows: The three-level checksum is generated using default parameters; the interlocked storage uses only basic partitioning, that is, the BCH code is written to the spare area on the same page, the CRC and LDPC codes are written to the check area, and the mapping table is recorded; no adaptive adjustment is performed; transactional writes are performed with basic atomic operations, and the log only records the address and type.

[0010] Preferably, determining whether the chip environment status of the data to be written is normal further includes: If an anomaly is identified, the environmental status type in the environmental label will be further identified. If a single environmental label is identified, the redundancy ratio will be adjusted according to the label to generate a three-level check code. Interlocked storage adds multimodal redundancy chains, which, based on the basic partition, links independent blocks to neighboring blocks into an ordered chain, forming a linear chain link. Spatiotemporal information is embedded in each link, denoted as a multimodal redundancy chain. The multimodal redundancy chains are arranged into a mesh structure. If one block is interrupted, it is recovered from neighboring block voting, forming a self-healing network. Adaptive adjustment is achieved by adding retry loops and shadow bits; transactional write execution is enhanced by logging. Each block contains the current block's data, checksum, previous block hash, and environment tag.

[0011] Preferably, the step of continuing to identify the environmental state type in the environmental label if an anomaly is identified further includes: If it is a mixed environment label, then the redundancy ratio is adjusted according to the label to generate a three-level check code; Adaptive adjustment uses a composite algorithm, specifically: read the environmental state type from the environmental label, load the sliding window, analyze the comprehensive risk, generate composite rules based on the risk, apply them to the block according to the execution order in the composite rules, pass the adjusted data into the interlocked storage, and use the enhanced chain backup. Transactional writes take precedence over the self-healing chain.

[0012] Preferably, the step of continuing to identify the environmental state type in the environmental label if an anomaly is identified further includes: If it is a sequential environment label, then the redundancy ratio is adjusted according to the label to generate a three-level check code; Adaptive adjustment detects changes, first uses a priority queue, and then switches to batch processing. Specifically: it obtains sequence labels from the environment recognition module, loads the sliding window and the data to be written, and detects environmental changes; it initializes the priority queue, i.e., builds the queue; it writes high-priority blocks first, and if an environmental change is detected, it switches to batch processing to execute the write; it monitors window updates and switches, integrates them into interlocked storage, and uses continuous chain links in the interlocked storage. The order of log entries written in transactions changes.

[0013] Preferably, the method of using progressive decoding includes: The initial decoding order is CRC→BCH→LDPC, which means reading the data frame and its CRC. If the CRC passes, the data is delivered directly. If the CRC fails, the BCH code error correction within the page is triggered. After correcting the bit error, the CRC is verified again. If successful, the data is delivered. If the BCH cannot be corrected, LDPC decoding is performed. The environment tag is read, and the initial decoding order is adjusted according to the environment state type. Decoding is performed according to the adjusted order, and during the decoding process, neighbor chain recovery is performed based on the self-healing network.

[0014] Preferably, the self-healing repair method includes: Read the complete environment tags and extract key elements; The design repair mode consists of time series interpolation, correlation verification, and fuzzy extraction. Predefined mapping rules are used to assign a primary mode and an auxiliary mode to the key elements of the input. The assignment results are used as the processing mode. The processing mode is used to repair the input data. In particular, an auxiliary mode is added when the confidence level in the environmental label is lower than the standard. The specific processing steps of time series interpolation are as follows: Load the sequences before and after the damaged block, input them into LSTM, use a sliding window to fill the missing parts through interpolation, and output a continuous sequence; The specific process of correlation verification is as follows: extract the semantic structure of the corrupted data, compare it with the protocol rules, and if it does not conform, correct it and output the verified data fragment; Fuzzy extraction process: statistical analysis of damaged data, calculation of statistical intervals, addition of confidence levels, output of value range and confidence level; The recovery report includes the recovered data, data status markers, confidence level, rules used for the remediation, environment tags, timestamps, and audit signatures.

[0015] A method for verifying data read / write operations on a high-reliability memory chip includes: S1: Real-time acquisition of data from multiple sensors, comprehensive judgment based on sliding window and predefined high-risk environment types, and generation of environment labels; S2: Determine the environment status based on the environment label. If it is normal, perform transactional writes according to the default parameters and basic partitions. If it is abnormal, adjust the redundancy and storage structure according to the specific type and perform the corresponding enhanced write process. S3: Set a self-refresh strategy based on environment tags, periodically scan, read, correct errors and rewrite the hibernation block, and update the log; S4: Respond to read requests, select a decoding strategy based on environment tags, prioritize progressive decoding, perform self-healing repair after failure, and generate a recovery report output.

[0016] The technical effects and advantages of the high-reliability memory chip data read / write verification method of the present invention are as follows: The multimodal environment perception module actively identifies and classifies extreme environments (such as high temperature, high vibration, deep water immersion, etc.) and dynamically generates environment labels with confidence levels, providing accurate and reliable decision-making basis for subsequent adaptive adjustments, thereby enhancing the system's ability to recognize and respond to complex physical environments from the source.

[0017] Secondly, the write module can dynamically adjust redundancy strategies and storage structures based on environmental tags. In abnormal environments, it automatically increases verification strength, adopts interlocking storage and multimodal redundancy chain technology, significantly enhancing the robustness of the data write process, effectively resisting problems such as "weak writes" and write interruptions, and ensuring the integrity of verification information and the reliability of data storage.

[0018] The storage module can formulate differentiated refresh strategies based on environmental tags, periodically scan, correct errors, and rewrite dormant data blocks, effectively suppressing the risk of error accumulation or spread due to environmental pressure during storage, and achieving persistent and intact data preservation.

[0019] The reading module adopts an environment-aware adaptive decoding strategy, prioritizing efficient progressive decoding. In case of failure, it can activate a self-healing repair mechanism that integrates time series interpolation, correlation verification, and other methods, which greatly improves the success rate and accuracy of data repair under high error rate conditions, avoids the loss of critical data due to irreparable errors, and provides a solid guarantee of data authenticity for responsibility identification and system improvement.

[0020] In summary, through the synergistic effect of environmental awareness, adaptive coding, intelligent storage management, and enhanced fault recovery, the reliability of data reading and writing of storage chips under extreme conditions is comprehensively improved. This solves the industry pain point that traditional verification mechanisms cannot work effectively in physically extreme environments and has significant application value. Attached Figure Description

[0021] Figure 1 This is a schematic diagram of the structure of a high-reliability memory chip data read / write verification method according to the present invention; Figure 2 This is a schematic diagram illustrating the steps of a high-reliability memory chip data read / write verification method according to the present invention; Figure 3 This is a structural diagram of an electronic device for a high-reliability memory chip data read / write verification application according to the present invention. Detailed Implementation

[0022] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0023] Example 1 Please see Figure 1 , Figure 2 and Figure 3 This embodiment provides a high-reliability memory chip data read / write verification system and method, which may specifically include the following steps: The essence of data read / write verification is to ensure the integrity and accuracy of data (adding a check code, such as ECC or CRC, during writing; verifying and correcting during reading). High-reliability storage chip data read / write verification systems face great challenges in extreme environments. This difficulty stems directly from the physical extremes of the scenario (such as high temperature, impact, water immersion), which can significantly increase the error rate of storage chips (such as eMMC NAND flash memory), causing traditional verification mechanisms to fail.

[0024] Chips (such as eMMC NAND flash memory) are prone to bit flips, data block corruption, or read / write channel failures under conditions of high temperature (1100℃ for 15 min or 260℃ for 120 min), deep water immersion (100m for 48 hours), high impact (compliant with GB / T 19056-2021), vibration, and compression (10kN for 5 min). The data error rate may rise to 10^-6~10^-4 (far exceeding the normal 10^-12) due to environmental interference. For example, fire may cause deformation of the internal crystal structure of the chip, resulting in multiple bit errors during data reading; water immersion may cause short circuits, interfering with the generation / verification of checksums; and impacts may cause data block corruption.

[0025] The read / write verification process typically consists of three stages: writing (generating verification), storing (persisting), and reading (verifying / correcting). This difficulty persists throughout the read and write processes, including: Write Phase: When data (such as CAN bus logs from 30 seconds prior to an incident or 1080P video frames) is input, the system needs to calculate the checksum in real time (e.g., adding redundant bits). However, under vibration / high temperature conditions, the write process may be interrupted, resulting in an incomplete checksum (e.g., some bits not written). Under extreme conditions, the chip's programming voltage may be unstable, causing "weak write" (data is prone to flipping).

[0026] Reading Phase: During disaster recovery, the system reads data and compares checksums. If there are too many errors (e.g., a sudden 4-8 bit error), standard checks (such as parity checks) can only detect but not correct them, leading to data loss or misjudgment.

[0027] Example of a problem: Write: Input data "10101010", calculate the ECC code and add it as "101010101011".

[0028] Extreme interference: High temperature causes 2 bits to flip, and the stored value becomes "101011101011".

[0029] Reading: The verification detects an error, but if the mechanism only supports unit error correction, the original data cannot be recovered, resulting in the loss of key evidence (such as autonomous driving decision logs).

[0030] Error detection / correction directly affects the success rate of verification. If errors cannot be corrected, the system cannot provide reliable data. The verification system may misjudge or fail to correct errors, resulting in the loss of accident data and the inability to restore the truth (such as whether the driver or the vehicle's intelligent driving system had control), which affects the clarification of legal responsibilities and the improvement of the vehicle.

[0031] Based on this, the technical solution of this design is as follows: At the start of the write phase (executed before data input), it runs on the ARVS-EE controller (embedded processor). It runs periodically every 10ms (the sampling frequency is configurable from 5-50ms, adjusted according to the load to ensure real-time performance). The goal is to identify critical environments faced by the memory chip and generate tags to guide subsequent steps.

[0032] Real-time sensor data is acquired, including temperature (°C), vibration intensity (g), pressure (MPa), humidity (%RH), and acceleration (g). This data originates from chip-integrated sensors and auxiliary interfaces (such as the vehicle's CAN bus) and maintains a sliding window to store the most recent time-series data (e.g., a window size of 10 sampling points covering a 100ms time span). This window data is used to analyze trends and sequential changes (e.g., gradual temperature increases or a sharp increase in humidity after a peak). After acquisition, preprocessing (e.g., filtering to remove noise) is performed to ensure data reliability. For the currently collected data, a check is performed based on the safety values ​​in the prior environmental knowledge, and the overall performance of the data is calculated. (For example, overall performance = 0.4 × temperature deviation + 0.3 × vibration intensity + 0.2 × pressure value + 0.1 × humidity value, where 0.4, 0.3, 0.2, and 0.1 are weighting coefficients. These data are not fixed values ​​and can be preset through experimental data analysis. The calculation process is dimensionless and all values ​​are normalized to obtain an overall evaluation value. That is, only pure numerical calculations are used, without involving units. Of course, the overall performance can also be obtained in other ways, as long as it achieves a comprehensive evaluation of the collected data.) The length of the sliding window should be greater than the safety limit to facilitate the analysis of the time sequence, preferably 2-3 times the safety limit.

[0033] If the overall performance is not lower than expected and does not match any of the high-risk environment types in the prior knowledge of the environment, then the environment status of the chip is determined to be non-hazardous, and the environment label {normal_confidence 100%} is output. If the overall performance exceeds expectations or matches at least one high-risk environment type in prior environmental knowledge, the chip's environmental state is determined to be dangerous. Based on the data sequence within the sliding window, the specific environmental state type is determined, and an environmental label {Abnormal_Environmental State Type - ()_Confidence} is output. For example, {Abnormal_Single Environment - (High Temperature)_Confidence 95%} or {Abnormal_Sequential Environment - (High Impact → Deep Water Immersion)_Confidence 92%} is recorded in the metadata log (using a JSON file format in a dedicated verification area, for example: {Timestamp: 2023-10-01T12:00:00, Label: Abnormal_Single Environment - (High Temperature)_Confidence 95%, Overall Performance: 65, Data Source: Sensor + Historical Logs}). The log uses a circular buffer mechanism (size limit <1MB) for easy post-disaster auditing. Labels are generated in string format.

[0034] The expected value refers to the minimum value of the chip's overall performance under normal environmental conditions, which is judged based on historical data and experimental calculations. It is generally within the range of [0.5, 1].

[0035] Prior environmental knowledge includes: High-risk environment types are predefined, including high-temperature environments, high-vibration environments, high-impact environments, deep-water immersion environments, and compression environments. The criteria for each type are as follows: a high-temperature environment is defined when the chip temperature exceeds the safe temperature value and the duration exceeds the safe time limit [e.g., in testing chip manufacturing materials and safe production, continuous exposure to 110°C for 15 minutes or 260°C for 3 minutes is considered a high-temperature hazard]. A high-vibration environment is defined when the chip vibration intensity exceeds the safe vibration value and the duration exceeds the safe time limit [e.g., when a vehicle bumps or mechanical vibration periodically affects the chip, an interference vibration intensity exceeding 5g and a duration exceeding 1 second is considered a high-vibration environment]. A high-impact environment is defined when the chip acceleration peak exceeds the safe acceleration value [e.g., in a single collision event, according to GB / T...]. [19056-2021 sets the safe value for peak acceleration to 50g]. When the chip pressure exceeds the pressure safety value or the humidity exceeds the moisture safety value and the duration exceeds the time safety limit, it is recorded as a deep water immersion environment. [For example, in experimental testing, the chip's maximum water depth is 100m, and the pressure here is approximately 1MPa. In this case, the pressure safety value can be set to 1MPa. Or, if the humidity exceeds 90% and the duration exceeds 1 minute, it will cause the chip to short circuit or channel failure. In this case, it is set as a deep water immersion environment.] When the chip pressure exceeds the pressure safety value and the duration exceeds the time safety limit, it is recorded as a compression environment. [For example, in experimental testing, the condition for physical deformation to cause damage is a pressure exceeding 10kN and a duration exceeding 5 minutes. In this case, the safety value is 10kN and the safety limit is 5 minutes.] The aforementioned safety values ​​and safety limits are not fixed values ​​for a certain data type, but rather refer to the threshold standards for a chip to be in a safe state under different conditions. Safety values ​​and safety limits can be determined based on experimental data, or set based on expert experience or national safety production standards.

[0036] The design of chips is based on three environmental states: single environment, mixed environment, and sequential environment. A single environment means that the chip is in only one type of high-risk environment (e.g., only a high-temperature environment without other interference). A mixed environment means that the chip is in more than one type of high-risk environment without any order of occurrence (e.g., facing both high temperature and high vibration at the same time). A sequential environment means that the chip is in more than one type of high-risk environment with a clear time sequence of occurrence (e.g., high impact followed by deep water immersion). No sequence of occurrence refers to the absence of a clear temporal order, such as extremely short intervals (e.g., less than 3ms) or simultaneous occurrences, such as high temperature followed by vibration within the high temperature. A clear temporal order refers to events that can be clearly determined in sequence, such as high temperature occurring first, followed by vibration, and finally impact.

[0037] The default execution mode during the write phase, assuming the environment label is normal (i.e., no high-risk environment), is designed for efficient data writing without additional hardening measures. The entire execution process runs on the controller.

[0038] Read the environment tag of the data to be written. If it is recognized as normal, the writing process is as follows: Generate a three-level checksum using default parameters; Specific steps for generating a level 3 checksum using default parameters: A1: Divide the data to be written into pages, frames, and superblocks; A2: Calculate the BCH code for each page of data. For example, input 8-bit data "10101010", generate a 12-bit code "101010101011" (2 bits for error correction), and add the BCH code to the end of the page.

[0039] A3: Divide the frame into 512-byte blocks, generate a 32-bit checksum using CRC-32, and append it to the end of the block.

[0040] A4: Calculate the LDPC code for the superblock. For example, add 10% redundant bits to the input data to form the error-correcting codeword.

[0041] Output: Encoded data with three levels of checksum.

[0042] Interlocked storage is an innovative design that logically links data and checksums, ensuring that checksum information is more secure than the data. Unlike the simple addition of existing technologies, it forms a "protective net": basic checksums coexist with the data, while advanced checksums are separated to a more reliable area. This prevents "all data from being lost" in extreme environments (such as high temperatures damaging the data but the checksum surviving).

[0043] Interlocked storage uses only basic partitioning, that is, the BCH code is written to the spare area on the same page, the CRC and LDPC codes are written to the check area, and the mapping table is recorded. Using only basic partitions, the software manages the partitions (e.g., virtually mapped as "data area" and "checksum area") through the Flash Translation Layer (FTL) driver. Basic partitions do not enable multiple backups or encryption; they are simply written to and use only a minimal partition configuration (without adding extra backups or chained structures) to conserve resources. Specifically: BCH codes are stored in a spare area within the data pages (the spare area is such as 16-128 bytes of reserved flash space); advanced checksums such as CRC and LDPC are stored in a dedicated "checksum area" (referring to a physically more robust storage area). This achieves tight binding between data and basic checksums, with advanced checksums protected off-site.

[0044] The mapping table is a software memory table used to record association information such as block ID, storage address, and check type (e.g., {block ID:1, address:0x1000, type: data+BCH}), which facilitates quick location and association during reading.

[0045] Adaptive adjustment refers to dynamically modifying parameters to address environmental risks under high-risk tags. Under normal tags, "no adaptive adjustment" means skipping these optimizations and directly using fixed default parameters to avoid unnecessary computational overhead and ensure fast and stable writes under normal conditions.

[0046] Transactional writes are performed with basic atomic operations, and the log only records the address and type; Transactional writes borrow from database concepts, treating a single write operation (data + checksum) as an "atomic operation" (an atomic operation is either entirely successful or entirely unsuccessful and indivisible). Atomicity is achieved through locking mechanisms (such as mutexes).

[0047] Logs are used to record transactional writes, facilitating disaster recovery. Under normal tags, logs record only minimal information (without adding environment tags or hashes) to save space. Address refers to the storage location (e.g., flash block / page address); type refers to the data / checksum type (e.g., video frame or BCH code).

[0048] A multimodal redundant chain is added on top of the basic partitioning, similar to a simplified blockchain structure, designed to cope with single high-risk environments (such as bit flips or interruptions caused by high temperatures). The entire process (running on the controller) is used to enhance the self-healing and consistency of the data.

[0049] Under a single environment tag, data blocks (such as flash pages or superblocks) are linked together, with each block embedding the hash value of the previous block and the current environment tag, forming a continuous "chain". This creates a self-healing network: if a block is damaged due to an interruption (such as vibration or power outage), logical consistency can be restored from adjacent blocks. Its purpose is to prevent data silos and ensure that even in high-risk environments, writes can "self-heal" and recover, rather than being completely lost.

[0050] If an anomaly is identified, the environmental status type in the environmental label will be further identified. If a single environmental label is identified, the redundancy ratio will be adjusted according to the label to generate a three-level check code. The process of generating codewords using library functions for Level 3 checksums involves step-by-step calculation: first, BCH (page-level), then CRC (frame-level), and finally LDPC (block-level). Level 3 checksums are the core protection mechanism; the page-level BCH code is used for basic error correction, the frame-level CRC for fast detection, and the block-level LDPC code for advanced error correction. Specifically, Level 3 checksums include: The first level is the intra-page BCH code. For data written to one page of flash memory (e.g., 4KB in size), a BCH code with strong error correction capability is calculated as the basic protection layer.

[0051] The second level is frame-level CRC, which divides the data (such as a frame of video or a set of CAN signals) into blocks (e.g., 512 bytes / block) and calculates the CRC-32 code for each block. This facilitates rapid location of the error range and provides granular control for subsequent recovery.

[0052] The third level is the block-level LDPC code. Multiple pages (or even multiple blocks) of data are grouped into a superblock (e.g., 256KB in size), and a long codeword LDPC code is calculated for it. This is crucial for handling high error rates in extreme environments.

[0053] Interlocked storage adds multimodal redundancy chains, which means that on the basis of basic partitioning, independent blocks are linked to neighboring blocks to form an ordered chain, forming a linear chain link. Spatiotemporal information is embedded in each link, which is called a multimodal redundancy chain. The multimodal redundancy chains are formed into a mesh structure. If one of the blocks is interrupted, it is restored from the neighboring block voting, forming a self-healing network. Linear chains are similar to the "chain" in blockchain, but are lighter and not distributed ledgers; instead, they are self-healing chains with local storage. Ordered chains link data chronologically. Spatiotemporal information can include temporal and spatial modalities. The temporal modality refers to sequential hashing (representing the temporal sequence linking of blocks, such as the previous block hash ensuring the writing order), while the spatial modality refers to tags being backed up to different partitions (representing spatial redundancy, such as copying tags to the checksum and backup areas).

[0054] Once a linear chain of links forms a network, the chain can automatically detect and repair damage (if a block is interrupted, the hash of neighboring blocks can be verified and reconstructed), enhancing self-healing capabilities. In single high-risk environments (such as high-temperature write interruptions), the chain provides redundant clues to ensure data logical consistency (e.g., knowing that "this block is a continuation of the previous one"), preventing data loss during interruptions. Combined with environment tags, the chain records context (e.g., a "high-temperature" tag indicates priority for correcting bit flips during recovery), reducing the error rate (from 10^-6 to 10^-8), improving reliability, and providing clues for the read phase. This transforms passive storage into an active self-healing network to cope with extreme interruptions.

[0055] Each block contains the current block's data, checksum, previous block hash, and environment tag; The previous block hash refers to the digital digest of the contents of the previous block (such as a fixed-length string "abc123" calculated using the SHA-256 algorithm). If this is the first block in the chain, the hash is set to empty.

[0056] The hash and environment tag are written to a specified location in the current block (e.g., a 32-byte hash and a 64-byte tag are written to the end of the spare area). The chain mapping table is essentially a software memory table. It is stored according to basic partitioning rules (data to the data area, high-level code to the checksum area) to ensure the persistence of chain links.

[0057] Network structures, such as those with branches or rings (e.g., block 10 hashes pointing to block 1), can form self-healing networks by assigning nodes as blocks and edges as multimodal redundant chains.

[0058] Interruption detection is achieved through a proactive inspection and verification mechanism to detect write anomalies in real time. When writing each block, a timer is started (e.g., expected to complete in 2ms). After writing, the block is read back immediately, and the contents are compared. If a timeout occurs (> expected time), readback fails (e.g., CRC mismatch), or the environment label indicates a high risk (e.g., confidence <80%), an interruption is determined.

[0059] Recovery from neighboring blocks refers to the process of reading the preceding and following neighboring blocks (such as blocks 1 and 3) if a block is found to be broken (e.g., block 2) and calculating the neighboring block hashes (e.g., the hash of block 1 should link to block 2). The process involves using the processing method corresponding to the tag (e.g., applying bit flip error correction when the high temperature tag indicates recovery), reaching a consensus through neighboring block voting (e.g., if 2 / 3 of the neighboring block hashes point to the same pattern, rebuilding the block data), rewriting the reconstructed data to the corrupted block (e.g., using the hash of block 1 + high temperature tag error correction), and updating the chain map and metadata log (e.g., {Recover: Recover block 2 from block 1, Success: true (indicating successful recovery)}).

[0060] Adaptive adjustments are made by adding retry loops and shadow bits. Adding retry loops means increasing the number of retries. For example, the number of retries is set to 3. If the write fails, wait 1ms and then retry using the loop count. Adding shadow bits means copying key bits (key bits such as high-priority bytes or check bits) to the spare area, such as adding 5% redundancy.

[0061] Transactional writes are executed to strengthen the log; strengthening the log refers to enhancing the robustness of the record by adding additional information to the log (such as the current environment label and the hash of the current block).

[0062] If it is a mixed environment label, then the redundancy ratio is adjusted according to the label to generate a three-level check code; The adaptive adjustment using a composite algorithm specifically involves: reading the environmental state type from the environmental label, loading a sliding window, analyzing the overall risk, generating composite rules based on the risk, applying them to the block according to the execution order in the composite rules, passing the adjusted data into the interlocked storage, and using enhanced chain backup. Comprehensive risk can be analyzed using LSTM or decision tree analysis. The aim is to analyze the combined impact of multiple high-risk factors. For example, if the mixed label is high temperature and high vibration, then the comprehensive risk = flip rate - base * 2 + vibration intensity * 0.5; if it exceeds the threshold of 1.5, it is marked as high risk. Composite rules refer to the generated combination of adjustment parameters. For example, when the label is high temperature and high vibration, the composite rule could be retry count = 3, delay = 5ms, batch size = 256 bytes (first delay to avoid vibration, then retry writing).

[0063] Enhanced chained backup refers to adding multiple backups to different eMMC partitions on top of a chained connection, simulating RAID-like redundancy to address multiple simultaneous risks. Backups include a complete chain, replicated via FTL. It enhances robustness (recovery from others if one backup fails) and is suitable for hybrid environments (redundancy > 95%). The implementation steps are as follows: After adjustment, data is input (e.g., coded blocks with compound rules); a basic chain is built; the chain is copied to multiple partitions (e.g., the original chain to 0x2000, backup 1 to 0x3000, backup 2 to 0x4000), verified (read back and compare all backups); and the mapping table is updated (recording backup locations).

[0064] Example: In a mixed configuration, incoming adjustment data is backed up to partition 3; if partition 1 is damaged, it is restored from backup 2.

[0065] Transactional writes prioritize the execution of self-healing chains; specifically, under hybrid tags, the transaction process prioritizes the processing of self-healing chains (i.e., first build / verify the integrity of the chain, then execute the write), ensuring that the chain can be automatically repaired under hybrid risks.

[0066] Self-healing chains are an extension of enhanced chain backups: when a transaction starts, the chain is verified first (e.g., checking hash consistency). If corrupted, it is automatically repaired from backups before new data is written. Priority is implemented through a state machine (chain verification > data writing). Prioritizing chain integrity reduces the impact of mixed outages.

[0067] Implementation steps: Start, status marked as "Pending"; first verify the self-healing chain (e.g., check all backup hashes); if corrupted, repair (copy from backup); write new data (integrate into the chain); mark as "Committed", update the log.

[0068] Under the sequential environment label (e.g., {Abnormal_Sequential Environment - (High Impact → Deep Immersion)_Confidence 92%}), adaptive adjustment addresses high-risk events with time series by detecting changes (e.g., impact interruption followed by immersion short circuit). It first uses a priority queue (sorting data by priority, writing critical data first (e.g., CAN logs), delaying non-critical data), then dynamically switches to batch processing (dividing data into small chunks, such as 128 bytes / batch, and writing them batch by batch to prevent interruption) to match the sequential changes in the environment. Real-time detection using AI (e.g., LSTM-based sliding window analysis) can ensure that adjustment follows the sequence (e.g., writing critical data quickly during the impact period, and robustly batching during the subsequent immersion period).

[0069] If it is a sequential environment label, then the redundancy ratio is adjusted according to the label to generate a three-level check code; Adaptive adjustment detects changes, first using a priority queue, then switching to batch processing. Specifically, it obtains sequential labels (such as "high impact → deep water immersion") from the environmental recognition module, loads a sliding window and data to be written, and detects environmental transformation changes (environmental transformation changes can be analyzed based on the LSTM window; if the impact peak decays to <50g, the impact is determined to end; if the humidity is >90%, it is determined to be immersion mode).

[0070] An initial priority queue is established, i.e., a queue is built (sorted, e.g., high priority = critical data such as video frames, low priority = auxiliary logs); high priority blocks are written first, and if an environmental change is detected (e.g., the impact ends), the process switches to batch processing (divided into small batches, written batch by batch), and the write is executed (e.g., full speed during the queue period, with a 1ms delay per batch during the batch processing period); monitoring window updates and switching are integrated into the interlocked storage, and the interlocked storage uses continuous chain links; Integrating into interlocked storage, and using continuous chaining in interlocked storage, refers to a variant of interlocked storage under sequential tags. Adaptively adjusted data (e.g., priority queue + batch processing) is passed into the interlocked storage, and then continuous chaining is used. Here, the chain emphasizes continuity, bridging chains according to order changes (e.g., shock chains smoothly linking to soak chains). Specifically, using continuous chaining means adding bridging hashes (i.e., double hashing of the preceding and following sub-chains of the change point blocks) to the basic chain to ensure sequence integrity. It matches order changes and prevents chain breaks.

[0071] Implementation steps: Adjust incoming data; detect changes; construct a continuous chain (e.g., embed double hashes in the change point block, where the double hashes are a pre-hash hash + a post-dip hash); link sub-chains (e.g., shock sub-chain → bridge block → dip sub-chain); store and verify continuity; update the mapping.

[0072] Example: In sequence, the shock chain (blocks 1-5) is bridged to the soak chain (blocks 6-10), and the double hash of the changed block 5 ensures continuity.

[0073] Assuming the label is {Abnormal_Sequential Environment-(High Impact → Deep Water Immersion)_Confidence 92%}, 8KB of data (4 pages) is written, and the window displays the impact peak of 60g (initial) and the subsequent humidity of 95% (change point).

[0074] The priority queue is to write critical page 1 (CAN log) first, and then delay writing non-critical page 4.

[0075] After the change, batch processing will divide the remaining pages into 128-byte batches and write them one batch at a time (to prevent interruption from soaking).

[0076] The system ensures critical data is preserved during the impact phase and the overall process remains stable during the soaking phase. In sequential environments (e.g., impact followed by soaking), risks gradually change. Priority queues protect critical data (e.g., instantaneous logs from an incident), while batch processing ensures subsequent stability (e.g., preventing short circuits during soaking). Real-time switching minimizes the impact of interruptions (e.g., fast writes during the impact phase, slow batch writes during the soaking phase).

[0077] Transactional writes record changes in log order. Specifically, this means that under the sequence label, the transaction log additionally records the sequence of environmental changes (e.g., "shock → soaking"), facilitating post-disaster auditing and reconstruction. The implementation steps are as follows: the log extends fields to record change points (timestamp + label change) and dynamically appends them within the transaction.

[0078] Generating a Level 3 checksum by adjusting the redundancy ratio based on the tag refers to dynamically modifying the redundancy ratio of the checksum (mainly the redundancy ratio of LDPC bits, adjusted from the default 10% to a higher value to increase error correction capability) based on the type of environmental tag, confidence level, and specific high-risk environment, and then generating codewords. Specifically, under different environmental tags, adjustments are made for high-risk situations (e.g., increasing redundancy for bit flipping in a single tag, increasing overall redundancy by 20% for mixed tags to cope with superposition, and transitional adjustments for sequential tags, such as an initial 15% followed by a decrease to 10%). The generation process is a step-by-step calculation: first BCH (page level, default unchanged), then CRC (frame level, default unchanged), and finally LDPC (block level, redundancy adjusted), and tag-driven parameters (e.g., adding an extra 5% for confidence <80%). This adapts to different risk levels, improves error correction, and balances efficiency. The specific implementation process is as follows: X1: Read the tag (e.g., single high temperature, 95% confidence); X2: Calculate the adjustment ratio (e.g., Single: LDPC redundancy = default 10% + 15% = 25%; Mixed: 10% + 20% = 30%; Sequential: initial 15%, 10% after change). X3: Segment data (page / frame / superblock); X4: Generate BCH (fixed 2-bit error correction); Generate CRC (fixed 512-byte block); Generate LDPC (adjusted bitrate, bitrate 0.75 = 25% redundancy, using iterative algorithm to add bits); X5: Output encoded data.

[0079] Example: Under mixed labeling, LDPC redundancy is adjusted to 30%: Input a 256KB superblock, add 30% bits (error correction capability x3), and generate codewords.

[0080] The storage phase follows the write phase, providing persistent protection for the data by processing the written data (flash blocks with three-level checksums, chaining, and logging) to prevent silencing errors (such as high-temperature charge loss or vibration-induced flip-flops). It inherits the written metadata log (environment tag adjustment strategy) and redundancy chains (distributed backup). The entire process runs as a background scheduled task (e.g., hourly scan), managing partitions through the FTL driver to ensure data reliability during dormancy (inherited from the write self-healing network).

[0081] The self-refresh interval is calculated based on environmental tags, triggered periodically, scanning dormant blocks, reading and correcting errors, and then rewriting and updating the log after refresh. Specifically, the background periodically reads dormant data, corrects errors using the written three-level checksum, rewrites, and refreshes the charge. Calculating the self-refresh interval based on environmental tags means dynamically modifying the interval based on the tags traced back from the logs (e.g., 24 hours for normal tags, every hour for single high-temperature tags). Verification information is backed up to the eMMC logical partition, combined with redundant chain distributed storage, that is, copying the checksum (CRC / LDPC) and chain data to virtual logical partitions (e.g., A / B / C).

[0082] Implementation steps: Obtain the block address from the write phase and load the most recent environment tag; calculate the interval based on the tag (e.g., normal: 24 hours; single: 1 hour; mixed: 30 minutes; sequential: 1 hour initially, then 30 minutes based on changes). Set the scheduler (e.g., RTOS timer); periodically scan dormant blocks; read back the data and use the three-level checksum for progressive decoding (CRC verification → BCH error correction ≤ 2 bits → LDPC iterative decoding). If a chain exists, verify hash consistency; after correction, rewrite to the original block or a new block, and integrate the self-healing chain (if the block is corrupted, recover from neighboring chain voting); extract checksum information and the chain, read back and compare all backups / refreshes, and record extended logs (e.g., {refresh: success, backup partition: A / B, tag: single_high temperature, chain recovery: none}); end the task.

[0083] The read and recovery phase follows the storage phase and processes persistent data (flushed blocks, backup chains, and logs). Its goal is to verify / correct errors and maximize recovery (even in the event of severe damage). It inherits from the storage backups and logs, starting with the logs and integrating redundant chains of writes (neighbor chain self-healing) and algorithms (such as LSTM). The process responds to read requests (post-disaster retrieval) and includes progressive decoding, self-healing repair, and report generation, ensuring maximum information availability.

[0084] When a read request is received, the system responds to the request and loads a block from the storage partition. Then, it reads the environment label, selects the corresponding strategy, first uses progressive decoding, and if that fails, performs self-healing repair. After that, it outputs a recovery report.

[0085] Methods using progressive decoding include: The input is the read request and block address (inherited from the log), and the output is the corrected data plus the confidence level. The initial decoding sequence is CRC→BCH→LDPC, which means reading the data frame and its CRC. If the CRC passes, the data is delivered directly. If the CRC fails, the BCH code error correction within the page is triggered. After correcting the bit error, the CRC is verified again. If successful, the data is delivered. If the BCH cannot be corrected, LDPC decoding is performed. The LDPC iterative decoding capability can effectively correct multiple consecutive burst errors.

[0086] The system reads environment tags and adjusts the initial decoding order based on the environment state type. Decoding is then performed according to the adjusted order, and during decoding, neighbor chain recovery is performed using a self-healing network. For example, high-temperature tags (inherited from single-environment tags) are prioritized using LDPC because high temperatures easily cause multiple bit flips, and LDPC excels at handling burst errors. Specifically, the software traces back tags from the metadata log (JSON recorded during the write / storage phase, such as {tag:abnormal_single-environment-(high-temperature)_confidence 95%}), and then reorders the steps as LDPC→BCH→CRC. Similarly, parallel BCH+LDPC can be used to accelerate superimposed error handling. Sequential tags use sequence decoding bridging to match the change order; the specific order can be predefined based on the impact of different environments on the data. Bridging refers to a mechanism that uses LSTM to generate transitional data at points of change, ensuring logical consistency between preceding and following blocks (e.g., smoothly bridging vehicle speed data from "80 km / h" during the impact phase to "70 km / h" during the immersion phase). It is used to connect and fuse the decoding results of time-series data blocks. Specifically, it connects the decoding outputs before and after the environmental change at the transition points of the environmental sequence, such as (high impact → deep water immersion), ensuring a smooth and continuous decoding result for both blocks, forming a complete time-series recovery.

[0087] CRC verification involves reading the stored frame data (inheriting the second-level CRC-32 code from the write phase), calculating the current CRC value, and comparing it with the additional 32-bit checksum. The steps are as follows: Load frame data and the additional CRC value from the storage partition or backup (inherited from the log using the FTL address); calculate the current CRC; if the current CRC equals the additional CRC, the repair passes and the data is output; if they do not match, first read the spare frame from the adjacent chain (set during the write phase) to retry, and then proceed to the next sequential decoding step.

[0088] BCH error correction refers to the correction of page-level bit errors (≤2 bits) by the first-level BCH code written by the application. It inherits the basic protection from the write operation, handles small-scale errors (such as a single flip), acts as a bridge (failure leads to LDPC), and combines with the storage's self-refresh (resulting in more accurate BCH after refresh). Implementation steps: Inherit the page (4KB) and spare area BCH codes from the storage, input data into Berlekamp-Massey, calculate the error location (e.g., bit 3 and bit 7 flip), flip the error bits (≤2 bits), generate repair data, recalculate the BCH, and if it matches the original appended BCH code (because after BCH error correction, the BCH value needs to be recalculated and compared with the original BCH code appended during the write stage to confirm the correction is effective), then it succeeds; if it fails, it first uses neighbor chain self-healing and then retryes matching; if it still doesn't match, it proceeds to the next sequential decoding step.

[0089] The LDPC decoding application writes the third-level LDPC code and performs iterative decoding (e.g., using the Min-Sum algorithm, up to 50 iterations). It inherits the adjusted redundancy ratio (e.g., 25%) to handle bursty multi-bit errors. Specifically, from the inherited storage block (256KB) and LDPC code, the steps are: input to the Min-Sum algorithm, iteratively update the belief (e.g., check convergence every iteration); if convergence is achieved (convergence means the residual error is less than a threshold), output corrected data; otherwise, it fails. If it fails and there is a chain backup, it reads the spare block from the neighboring chain to retry.

[0090] Self-healing repair is a key part of the read and recovery phases. It is triggered when progressive decoding fails (judgment conditions such as LDPC failing to converge or confidence <70%). The goal is to maximize information extraction by utilizing context (environment tags, neighbor chain backups) even if the data is severely corrupted (such as sudden errors of more than 8 bits in extreme environments).

[0091] Self-healing and repair methods include: Read complete environment tags (including type, specific environment, and confidence level) from the metadata log (JSON format, inherited from the write / storage phase) and extract key elements (such as single type, high temperature, 95% confidence, and other key data). The design repair mode consists of time series interpolation, correlation verification, and fuzzy extraction. Predefined mapping rules are used to assign a primary mode and an auxiliary mode to the key elements of the input. The assignment results are used as the processing mode. The processing mode is used to repair the input data. In this process, an auxiliary mode is added when the confidence level in the environmental label is less than the standard (e.g., confidence < 80%). Time series interpolation is the process of estimating the missing part using preceding and following time series data. Specifically, the preceding and following sequences of the corrupted block are loaded (inherited from the storage backup), input into an LSTM, and a sliding window (inherited from the sliding window maintained during the write phase) is used. Interpolation (using linear or polynomial fitting calculations, e.g., missing value = (previous value + subsequent value) / 2 + noise correction) is used to fill the missing data, outputting a continuous sequence as the recovered data, and verifying consistency with the neighbor chain hash. Association verification is a process of verification / correction using layer protocols. Specifically, the semantic structure of the corrupted data (e.g., CAN frame header or frame tail, inherited from the write phase) is extracted, and protocol rules are compared (e.g., matching check fields). If they do not match, correction is performed (correction methods include filling with standard values ​​or borrowing from the neighbor chain backup), outputting the verified data fragment. Fuzzy extraction is the process used to output the possible range or most probable value and confidence level. Specific processing steps: Statistically analyze the damaged data, calculate the statistical interval (calculation method such as min-max + standard deviation, based on Monte Carlo simulation or Bayesian inference), and add a confidence level (at this time, the confidence level is expressed as a probability, i.e., the percentage that matches historical data), output the value range and confidence level, such as a value range of 70-75 with a confidence level of 90%; The recovery report includes the recovered data, data status markers (markers include original, corrected, or estimated, with estimates referring to the range of output values), confidence level, rules used for the repair, environment labels, timestamps, and audit signatures.

[0092] The mapping rules are predefined processing methods based on experimental tests for various environmental states of the chip. Specifically: For a single environmental label, if the confidence level is less than 80%, an auxiliary mode is added. For high temperature, the primary mode is fuzzy extraction, and the auxiliary mode is correlation verification. For high vibration, the primary mode is time series interpolation, and the auxiliary mode is fuzzy extraction. For high impact, the primary mode is correlation verification, and the auxiliary mode is fuzzy extraction. For deep water immersion, the primary mode is fuzzy extraction, and the auxiliary mode is time series interpolation. For compression, the primary mode is correlation verification, and the auxiliary mode is fuzzy extraction.

[0093] For mixed environment labels, if the confidence level is <80%, an auxiliary mode is added. For high temperature + high vibration, the primary mode is correlation verification + time series interpolation; the auxiliary mode is fuzzy extraction. For high temperature + high impact, the primary mode is fuzzy extraction + correlation verification; the auxiliary mode is time series interpolation. For high temperature + deep water immersion, the primary mode is fuzzy extraction + time series interpolation; the auxiliary mode is correlation verification.

[0094] The primary mode of high temperature + extrusion is correlation verification + fuzzy extraction; the secondary mode is time series interpolation.

[0095] The primary mode for high vibration + high impact is time series interpolation + correlation verification; the secondary mode is fuzzy extraction. The primary mode for high vibration + deep water immersion is time series interpolation + fuzzy extraction; the secondary mode is correlation verification. The primary mode for high vibration + compression is correlation verification + time series interpolation; the secondary mode is fuzzy extraction. The primary mode for high impact + deep water immersion is correlation verification + fuzzy extraction; the secondary mode is time series interpolation. The primary mode for high impact + compression is fuzzy extraction + correlation verification; the secondary mode is time series interpolation. The primary mode for deep water immersion + compression is fuzzy extraction + time series interpolation; the secondary mode is correlation verification. For combinations of three or more (e.g., high temperature + high vibration + high impact), the primary mode is all three modes used together (interpolation + correlation + fuzzy); the secondary mode is none.

[0096] For sequential environment labels, if the confidence level is <80%, an auxiliary mode is added. For example, the primary mode for high temperature → high vibration is time series interpolation; the auxiliary mode is fuzzy extraction. For high temperature → high impact, the primary mode is time series interpolation + correlation verification; the auxiliary mode is fuzzy extraction. For high temperature → deep water immersion, the primary mode is time series interpolation + fuzzy extraction; the auxiliary mode is correlation verification. For high temperature → compression, the primary mode is time series interpolation + correlation verification; the auxiliary mode is fuzzy extraction. For high vibration → high impact, the primary mode is time series interpolation + correlation verification; the auxiliary mode is fuzzy extraction. For high vibration → deep water immersion, the primary mode is time series interpolation + fuzzy extraction; the auxiliary mode is correlation verification. For high vibration → compression, the primary mode is time series interpolation + correlation verification; the auxiliary mode is fuzzy extraction. For high impact → deep water immersion, the primary mode is time series interpolation + fuzzy extraction; the auxiliary mode is correlation verification. For high impact → compression, the primary mode is time series interpolation + correlation verification; the auxiliary mode is fuzzy extraction. For deep-water immersion → compression, the primary mode is time series interpolation + fuzzy extraction; the secondary mode is correlation verification. For three or more sequences (e.g., high temperature → high vibration → high impact), the primary mode is time series interpolation with correlation or fuzzy auxiliary modes; there is no secondary mode.

[0097] The confidence score is generated during the writing phase and is calculated based on the convergence speed (number of iterations) of the LSTM model and the historical data matching rate (similarity with historical data of the same type). It represents the accuracy and credibility of the label itself.

[0098] Example: The tag {Abnormal_Single Environment-(High Temperature)_Confidence 90%} has a high confidence level, so the main mode is set to fuzzy extraction.

[0099] The tag {Abnormal_Single Environment-(High Temperature)_Confidence 75%} is used. If the confidence level is low, an auxiliary tag is added. The main mode is set to fuzzy extraction, and the auxiliary mode is set to correlation verification.

[0100] Example 2 Please see Figure 2This embodiment provides a high-reliability data read / write verification method for memory chips, which may specifically include the following steps: S1: Real-time acquisition of data from multiple sensors, comprehensive judgment based on sliding window and predefined high-risk environment types, and generation of environment labels; S2: Determine the environment status based on the environment label. If it is normal, perform transactional writes according to the default parameters and basic partitions. If it is abnormal, adjust the redundancy and storage structure according to the specific type and perform the corresponding enhanced write process. S3: Set a self-refresh strategy based on environment tags, periodically scan, read, correct errors and rewrite the hibernation block, and update the log; S4: Respond to read requests, select a decoding strategy based on environment tags, prioritize progressive decoding, perform self-healing repair after failure, and generate a recovery report output.

[0101] Example 3 Please see Figure 3 The present invention also provides an electronic device. Figure 3 This is a structural diagram of an electronic device 20 according to an exemplary embodiment. The content of the diagram should not be construed as limiting the scope of the invention. Specifically, the electronic device 20 may include: at least one processor 21, at least one memory 22, a power supply 23, a communication interface 24, an input / output interface 25, and a communication bus 26. The memory 22 stores a computer program, which is loaded and executed by the processor 21 to implement the relevant steps in the high-reliability memory chip data read / write verification method disclosed in any of the foregoing embodiments. Furthermore, the electronic device 20 in this embodiment may specifically be an electronic computer.

[0102] In this embodiment, the power supply 23 is used to provide operating voltage for each hardware device on the electronic device 20; the communication interface 24 can create a data transmission channel between the electronic device 20 and external devices, and the communication protocol it follows can be any communication protocol applicable to the technical solution of this invention, and is not specifically limited here; the input / output interface 25 is used to acquire external input data or output data to the outside world, and its specific interface type can be selected according to specific application needs, and is not specifically limited here.

[0103] In addition, the memory 22, as a carrier for resource storage, can be a read-only memory, random access memory, disk or optical disk, etc. The resources stored thereon can include operating system 221, computer program 222, etc., and the storage method can be temporary storage or permanent storage.

[0104] The operating system 221 is used to manage and control the various hardware devices on the electronic device 20 and the computer program 222, which may be Windows Server, Netware, Unix, Linux, etc. In addition to including a computer program capable of performing the high-reliability memory chip data read / write verification method executed by the electronic device 20 as disclosed in any of the foregoing embodiments, the computer program 222 may further include computer programs capable of performing other specific tasks.

[0105] Furthermore, the present invention also provides a computer-readable storage medium for storing a computer program; wherein, when the computer program is executed by a processor, it implements the aforementioned high-reliability memory chip data read / write verification method. Specific steps of this method can be found in the corresponding content disclosed in the foregoing embodiments, and will not be repeated here.

[0106] The above description is merely a preferred embodiment of the present invention, and the scope of protection of the present invention is not limited to the above embodiments. All technical solutions falling within the scope of the present invention's concept are within the scope of protection of the present invention. It should be noted that for users of ordinary technical skills, any improvements and modifications made without departing from the principles of the present invention should also be considered within the scope of protection of the present invention.

Claims

1. A high-reliability storage chip data read-write check system, characterized in that, include: Multimodal environment perception module: Real-time acquisition of sensor data, maintenance of a sliding window, judgment of chip environment status based on prior environmental knowledge, output of environment labels and recording to metadata log; Write module: Used to determine whether the chip environment status of the data to be written is normal. If it is normal, normal writing is used. If it is abnormal, the specific environment status type is identified, and the redundancy ratio, interlocking storage structure and adaptive strategy are dynamically adjusted to execute the corresponding writing process. Storage module: Calculates the self-refresh interval based on environment tags, triggers it periodically, scans the dormant block, reads and corrects errors, and then rewrites the update log after refresh; Read module: Used to respond to read requests, load blocks from storage partitions, read environment tags, select the corresponding strategy, first use progressive decoding, and if it fails, perform self-healing repair, and then output a recovery report.

2. The high-reliability memory chip data read-write check system according to claim 1, characterized in that, The method for real-time acquisition of sensor data, maintenance of a sliding window, determination of chip environment status based on prior environmental knowledge, output of environment labels, and recording to metadata logs includes: Sensor data includes temperature, vibration intensity, pressure, humidity, and acceleration, and is maintained within a sliding window. For the currently collected data, a check is performed based on the safety values ​​in the prior knowledge of the environment, and the overall performance of the data is calculated; If the overall performance is not lower than expected and does not match any of the high-risk environment types in the prior knowledge of the environment, then the environment status of the chip is determined to be non-hazardous, and the environment label {normal_confidence 100%} is output. If the overall performance exceeds expectations or matches at least one high-risk environment type in the prior knowledge of the environment, the chip's environment state is determined to be dangerous. The specific environment state type is determined based on the data sequence within the sliding window, and the environment label {abnormal_environment state type-()_confidence} is output and then recorded in the metadata log.

3. The high-reliability memory chip data read-write check system according to claim 2, characterized in that, The prior environmental knowledge includes: High-risk environment types are predefined, including high-temperature environment, high-vibration environment, high-impact environment, deep-water immersion environment, and extrusion environment. The criteria for each type are as follows: when the chip temperature exceeds the temperature safety value and the duration exceeds the time safety limit, it is classified as a high-temperature environment; when the chip vibration intensity exceeds the vibration safety value and the duration exceeds the time safety limit, it is classified as a high-vibration environment; when the chip acceleration peak exceeds the acceleration safety value, it is classified as a high-impact environment; when the chip pressure exceeds the pressure safety value or the humidity exceeds the moisture safety value and the duration exceeds the time safety limit, it is classified as a deep-water immersion environment; and when the chip pressure exceeds the pressure safety value and the duration exceeds the time safety limit, it is classified as an extrusion environment. The design of chips based on high-risk environment types includes three environmental states: single environment, mixed environment, and sequential environment. A single environment means that the chip is in only one type of high-risk environment. A mixed environment means that the chip is in more than one type of high-risk environment at the same time without any order of occurrence. A sequential environment means that the chip is in more than one type of high-risk environment with a clear time sequence of occurrence.

4. The high-reliability memory chip data read-write check system according to claim 3, characterized in that, The determination of whether the chip environment status for the data to be written is normal includes: Read the environment tag of the data to be written. If it is recognized as normal, the writing process is as follows: The three-level checksum is generated using default parameters; the interlocked storage uses only basic partitioning, that is, the BCH code is written to the spare area on the same page, the CRC and LDPC codes are written to the check area, and the mapping table is recorded; no adaptive adjustment is performed; transactional writes are performed with basic atomic operations, and the log only records the address and type.

5. The high-reliability memory chip data read-write check system according to claim 4, characterized in that, The determination of whether the chip environment status of the data to be written is normal also includes: If an anomaly is identified, the environmental status type in the environmental label will be further identified. If a single environmental label is identified, the redundancy ratio will be adjusted according to the label to generate a three-level check code. Interlocked storage adds multimodal redundancy chains, which, based on the basic partition, links independent blocks to neighboring blocks into an ordered chain, forming a linear chain link. Spatiotemporal information is embedded in each link, denoted as a multimodal redundancy chain. The multimodal redundancy chains are arranged into a mesh structure. If one block is interrupted, it is recovered from neighboring block voting, forming a self-healing network. Adaptive adjustment is achieved by adding retry loops and shadow bits; transactional write execution is enhanced by logging. Each block contains the current block's data, checksum, previous block hash, and environment tag.

6. The high-reliability memory chip data read-write check system according to claim 5, characterized in that, If an anomaly is identified, the process of further identifying the environmental state type in the environmental label also includes: If it is a mixed environment label, then the redundancy ratio is adjusted according to the label to generate a three-level check code; Adaptive adjustment uses a composite algorithm, specifically: read the environmental state type from the environmental label, load the sliding window, analyze the comprehensive risk, generate composite rules based on the risk, apply them to the block according to the execution order in the composite rules, pass the adjusted data into the interlocked storage, and use the enhanced chain backup. Transactional writes take precedence over the self-healing chain.

7. A high-reliability memory chip data read / write verification system according to claim 6, characterized in that, If an anomaly is identified, the process of further identifying the environmental state type in the environmental label also includes: If it is a sequential environment label, then the redundancy ratio is adjusted according to the label to generate a three-level check code; Adaptive adjustment detects changes, first uses a priority queue, and then switches to batch processing. Specifically: it obtains sequence labels from the environment recognition module, loads the sliding window and the data to be written, and detects environmental changes; it initializes the priority queue, i.e., builds the queue; it writes high-priority blocks first, and if an environmental change is detected, it switches to batch processing to execute the write; it monitors window updates and switches, integrates them into interlocked storage, and uses continuous chain links in the interlocked storage. The order of log entries written to transactions changes.

8. A high-reliability memory chip data read / write verification system according to claim 7, characterized in that, The method of using progressive decoding includes: The initial decoding order is CRC→BCH→LDPC, which means reading the data frame and its CRC. If the CRC passes, the data is delivered directly. If the CRC fails, the BCH code error correction within the page is triggered. After correcting the bit error, the CRC is verified again. If successful, the data is delivered. If the BCH cannot be corrected, LDPC decoding is performed. The environment tag is read, and the initial decoding order is adjusted according to the environment state type. Decoding is performed according to the adjusted order, and during the decoding process, neighbor chain recovery is performed based on the self-healing network.

9. A high-reliability memory chip data read / write verification system according to claim 8, characterized in that, The self-healing repair method includes: Read the complete environment tags and extract key elements; The design repair mode consists of time series interpolation, correlation verification, and fuzzy extraction. Predefined mapping rules are used to assign a primary mode and an auxiliary mode to the key elements of the input. The assignment results are used as the processing mode. The processing mode is used to repair the input data. In particular, an auxiliary mode is added when the confidence level in the environmental label is lower than the standard. The specific processing steps of time series interpolation are as follows: Load the sequences before and after the damaged block, input them into LSTM, use a sliding window to fill the missing parts through interpolation, and output a continuous sequence; The specific process of correlation verification is as follows: extract the semantic structure of the corrupted data, compare it with the protocol rules, and if it does not conform, correct it and output the verified data fragment; Fuzzy extraction process: statistical analysis of damaged data, calculation of statistical intervals, addition of confidence levels, output of value range and confidence level; The recovery report includes the recovered data, data status markers, confidence level, rules used for the remediation, environment tags, timestamps, and audit signatures.

10. A method for verifying data read / write operations on a high-reliability memory chip, used to implement the high-reliability memory chip data read / write verification system described in any one of claims 1-9, characterized in that, include: S1: Real-time acquisition of data from multiple sensors, comprehensive judgment based on sliding window and predefined high-risk environment types, and generation of environment labels; S2: Determine the environment status based on the environment label. If it is normal, perform transactional writes according to the default parameters and basic partitions. If it is abnormal, adjust the redundancy and storage structure according to the specific type and perform the corresponding enhanced write process. S3: Set a self-refresh strategy based on environment tags, periodically scan, read, correct errors and rewrite the hibernation block, and update the log; S4: Respond to read requests, select a decoding strategy based on environment tags, prioritize progressive decoding, perform self-healing repair after failure, and generate a recovery report output.

Images