An early termination determination method and system for memory array repair
By optimizing the redundancy repair algorithm for large-capacity memory chips through breadth-first search based on row-column connectivity and greedy matching lower bound estimation algorithm, the problems of premature termination and high computational complexity are solved, and efficient early termination judgment and repair are achieved, meeting the requirements of mass production testing.
Patent Information
- Application Number
- CN202611306306.9
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2026-08-26
- Publication Date
- 2026-11-17
AI Technical Summary
In the mass production testing of high-capacity, high-bandwidth memory chips, existing technologies suffer from redundancy repair algorithms that suffer from overkill due to premature termination conditions, high computational complexity, and excessively long repair times, failing to meet the time window requirements for mass production testing.
We employ a breadth-first search method based on row-column connectivity and a greedy matching lower bound estimation algorithm. By combining basic fast verification rules and depth-first search with a branch and bound method, we optimize the calculation of the lower bound of resource requirements for fault groups and achieve early termination judgment.
It significantly reduced the overkill rate, improved the lower bound compactness, shortened the repair time, increased the computational efficiency by 4 times, met the time window requirements for mass production testing, and improved the chip yield.
Smart Images

Figure CN123114818A_ABST
Abstract
Description
Technical Field
[0001] This invention relates to the field of semiconductor memory manufacturing and testing technology, specifically to a method and system for early termination judgment of memory array redundancy repair based on the FGPM (FaultGroup Pattern Matching) algorithm, which is particularly suitable for the mass production testing and repair process of high-capacity, high-bandwidth memory chips such as DDR5 and HBM3. Background Technology
[0002] As semiconductor process nodes continue to evolve to 3nm and below, the storage density of modern memory chips has increased exponentially, with a single DDR5 chip reaching 64Gb and HBM3 chips even exceeding 1TB. However, memory cell failures caused by process defects, material inhomogeneity, and lithography errors have become increasingly serious, with the number of failure points increasing from dozens in the early days to hundreds or even thousands.
[0003] To improve chip yield, the industry commonly employs redundancy repair technology, which involves pre-designing a certain number of spare rows and columns in the memory array. During mass production testing, an automated test equipment (ATE) performs a full address traversal test on the memory array, using algorithms to verify the read and write operations of memory cells, collecting the row and column addresses of all faulty cells, and constructing a two-dimensional fault matrix. This fault matrix is then input into a redundancy repair algorithm for decision-making, mapping the row or column containing the faulty cell to the corresponding spare resource through a repair circuit. However, as array size increases and the number of fault points grows, the optimization problem of combining redundant resources with fault points has evolved into an NP-hard combinatorial coverage problem. Traditional repair algorithms mainly include: 1. Exhaustive search algorithm: Iterates through all possible row / column repair combinations to find the optimal solution. However, the computational complexity of this algorithm increases exponentially. When dealing with large-scale arrays, the repair time for a single chip can reach several seconds or even tens of seconds, which cannot meet the millisecond-level time window requirements for each chip in mass production testing.
[0004] 2. Greedy Algorithm: This algorithm employs a row-first or column-first repair strategy. It is fast to compute but has a low repair rate and can easily lead to the incorrect discarding (overkill) of repairable chips.
[0005] 3. FGPM Algorithm: By grouping large-scale problems into multiple smaller subproblems, the computational complexity is significantly reduced. However, the original FGPM algorithm's early termination condition is too conservative, resulting in a serious overkill problem. Statistics show that in the mass production of 16Gb DDR4 chips, the overkill rate is as high as 3%-5%, causing huge economic losses. At the same time, the tightness of the original early termination condition bound is insufficient, leading to a large number of unnecessary subsequent calculations and prolonging the repair time. Summary of the Invention
[0006] The purpose of this invention is to overcome the shortcomings of the prior art and provide an early termination judgment method and system for memory array repair, so as to significantly shorten the repair decision time and reduce the testing cost while ensuring the repair rate, thereby meeting the mass production testing requirements of large-capacity memory chips, and solving the problems of high overkill rate, insufficient lower bound tightness, and low computational efficiency of the early termination conditions of the existing FGPM algorithm.
[0007] To achieve the above-mentioned objectives, the present invention adopts the following technical solution: The early termination determination method for memory array repair of the present invention is characterized by comprising the following steps: Step 1: Obtain the memory fault matrix and make a judgment to obtain the fault rows and columns that must be repaired first, and repair them to obtain the repaired fault rows and columns as well as the remaining fault rows and columns. Step 2: Use a breadth-first search method based on row-column connectivity to group the fault points in the remaining fault rows and columns to obtain single-fault fault groups and multi-fault fault groups, and calculate the statistical characteristics of each fault group. Step 3: Pre-screen each fault group using basic quick verification rules. If the basic verification is passed, proceed to Step 4; otherwise, the corresponding fault group is considered unrepairable, and the repair process ends. Step 4: Calculate the lower bound of the redundancy resource requirements needed for each pre-screened fault group using a greedy matching lower bound estimation algorithm. This lower bound is used to calculate the total global redundancy resource requirements, thereby determining whether the memory fault matrix is repairable. If it is determined to be repairable, proceed to Step 5; otherwise, end the repair process. Step 5: Using a depth-first search combined with a branch and bound method, find the optimal repair solution from the candidate repair solutions of each fault group that satisfies the global resource constraints and minimizes the total repair cost, and then execute it.
[0008] The early termination determination method described in this invention is also characterized in that step 1 includes: The number of fault points F_c in fault column c of the fault matrix is counted. When F_c is greater than the number of remaining available redundant rows R_rem, fault column c is determined to be a fault column that must be repaired first. The number of fault points F_r in any fault row r of the fault matrix is counted. If F_r is greater than the number of remaining available redundant columns C_rem, then the fault row r is determined to be the fault row that must be repaired first.
[0009] Furthermore, the statistical characteristics of each fault group in step 2 include at least the following: the total number of fault points N_f in any fault group, the number of different fault rows involved in the fault group N_fr, the number of different fault columns involved in the fault group N_fc, the number of fault rows containing two or more fault points in the fault group N_mr, and the number of fault columns containing two or more fault points in the group N_mc.
[0010] Furthermore, step 3 includes: Calculate the number of fault groups S containing a single fault point, the number of fault groups M containing multiple fault points, and the current remaining total repair resources Total_spare = R_rem + C_rem; If Total_spare < S, it means that the corresponding fault group is unrepairable, and the memory repair process is terminated. If Total_spare = S and M > 0, it indicates that the corresponding fault group is unrepairable, and the memory repair process is terminated. If Total_spare ≥ S + M, it means that the corresponding fault group has passed the basic verification.
[0011] Furthermore, the greedy matching lower bound estimation algorithm in step 4 includes: a. Initialize the current fault point set Current_Set to include all fault points in any pre-filtered fault group, and set the counter lower_bound=0; b. Calculate the row degree deg_row, column degree deg_col, and joint degree joint_deg = deg_row + deg_col for each fault point in Current_Set; where, row degree deg_row refers to the total number of fault points contained in any fault row r' in the current remaining fault set; column degree deg_col refers to the total number of fault points contained in any fault column c' in the current remaining fault set; c. Select the coordinates (r*, c*) of the fault point with the minimum cohesion; where r* represents the row coordinate of the fault point with the minimum cohesion, and c* represents the column coordinate of the fault point with the minimum cohesion. d. After assigning lower_bound+1 to lower_bound, remove the fault points in the row and column containing the fault point with the lowest degree of association from Current_Set; e. Determine if Current_Set is empty. If it is empty, it means that lower_bound is the lower bound of the resource requirements of the pre-filtered fault group. Otherwise, return to step b.
[0012] Furthermore, in step 4, the determination of whether the memory fault matrix is repairable is performed according to the following steps: Calculate the total global redundant resource requirements by summing the lower bounds of the requirements of all fault groups after pre-screening. , where m is the total number of fault groups after pre-screening; This represents the lower bound of the resource requirements for the kth fault group after pre-screening. If Sum_min_total ≤ Total_spare, then the memory fault matrix is determined to be repairable; If Sum_min_total > Total_spare, then the memory fault matrix is determined to be unrepairable.
[0013] The early termination judgment system for memory array repair of the present invention is characterized by comprising: The data preprocessing module is used to obtain the fault matrix in memory and make a judgment, thereby repairing the fault rows and columns that must be repaired first, and updating the repair status in the fault matrix. The fault grouping module is used to group the fault points in the remaining fault rows and fault columns based on connectivity, and to calculate the statistical characteristics of each fault group. The early termination judgment module is used to perform basic rule fast verification, greedy matching lower bound estimation and global resource requirement judgment on each fault group, so as to determine whether the memory fault matrix is repairable. The early termination judgment module includes: The basic rule verification unit is used to pre-screen basic fast verification rules based on the number of fault groups for a single fault, the number of fault groups for multiple faults, and the total remaining resources. The lower bound estimation unit is used to calculate the lower bound of resource requirements for each fault group after pre-screening using a greedy matching algorithm, so as to obtain the total global redundant resource requirements. The global determination unit is used to determine whether the memory fault matrix is repairable based on the total global redundant resource requirements. The repair scheme generation and execution module is used to generate the optimal repair scheme from the repairable fault matrix and execute the repair operation.
[0014] Compared with the prior art, the beneficial effects of the present invention are as follows: 1. Completely eliminates the overkill problem: The greedy matching lower bound estimation algorithm proposed in this invention can accurately calculate the minimum resource lower bound required to repair each fault group, ensuring that all repairable chips can pass the early termination judgment, thus completely avoiding the overkill problem existing in the original FGPM algorithm. In the mass production test of 16Gb DDR4 chips, the overkill rate was reduced from 3%-5% to 0%, and the yield was significantly improved.
[0015] 2. Improved lower bound tightness and reduced repair time: The lower bound tightness of this invention is 20%-30% higher than the original FGPM algorithm, enabling more accurate identification of unrepairable chips and early termination of unnecessary subsequent calculations. When processing a 64Gb DDR5 chip with 500 fault points, the average repair decision time is reduced from 12ms to 3ms, and the computational efficiency is improved by 4 times.
[0016] 3. Multi-layered filtering mechanism for high computational efficiency: This invention employs a multi-layered filtering mechanism of "fast verification of basic rules and greedy matching lower bound estimation." It first quickly filters out obviously irreparable cases using simple heuristic rules, and then performs precise calculations on the remaining cases. This mechanism keeps the overall computational complexity within O(n^2). 2 Within a polynomial time, it fully meets the millisecond-level time window requirements in mass production testing.
[0017] 4. Easy to implement in engineering: The algorithm logic of this invention is clear and the data structure is simple. It is easy to implement hardware acceleration in FPGA or ASIC and can be seamlessly integrated into existing high-speed test equipment without large-scale changes to the test process. Attached Figure Description
[0018] Figure 1 is a schematic diagram of the execution process of the greedy matching lower bound estimation algorithm; Figure 2 is a flowchart illustrating the novel early termination determination method of the present invention; Figure 3 Schematic diagram of the greedy matching lower bound estimation method in the early termination judgment method; Figure 4 Fault grouping diagram. Detailed Implementation
[0019] In this embodiment, an early termination determination method for memory array repair is provided, such as... Figure 2 As shown, it includes the following steps: Step 1: Determine the fault matrix of the memory, obtain the fault rows and columns that must be repaired first, and repair them. For any fault column c in the fault matrix, count the number of fault points F_c in fault column c. When F_c is greater than the number of remaining available redundant rows R_rem, then the fault column c is determined to be the fault column that must be repaired first. For any fault row r in the fault matrix, count the number of fault points F_r in fault row r. If F_r is greater than the number of remaining available redundant columns C_rem, then the row r is determined to be a fault row that must be repaired first.
[0020] Taking a 16Gb DDR4 chip from a certain manufacturer as an example, the chip adopts an 8-bank architecture, with each bank containing 8192 rows and 1024 columns. Each bank is configured with 32 redundant rows and 16 redundant columns. The test equipment obtained the fault matrix of a certain bank through ATE testing, which contained a total of 128 fault points. The initial redundancy resources R_rem=32 and C_rem=16.
[0021] First round of identification: After counting the number of faults in each row and column, it was found that there were 35 fault points in column 512, which is greater than the number of remaining redundant rows of 32, satisfying the judgment condition that F_c > R_rem. Therefore, column 512 was determined to be a column that must be repaired.
[0022] Repair execution: Prioritize repairing column 512, consuming 1 redundant column resource, after which C_rem=15; at the same time, clear 35 fault points on this column, and the total number of remaining fault points becomes 93.
[0023] Iterative verification: After updating the fault counts of all rows and columns, rescan the items that must be repaired. If no new rows / columns that meet the conditions for repair are found, the repair phase ends.
[0024] Step 2: A breadth-first search method based on row-column connectivity is used to group the remaining fault points in the memory fault matrix that must be repaired into single-fault groups and multi-fault groups. The statistical characteristics of each group of fault points are then calculated. Figure 4The diagram illustrates the grouping of the fault matrix. Each fault group cannot have fault points with the same coordinate positions as other fault groups in the same memory matrix. In practice, the statistical characteristics of each fault group include at least the following: the total number of fault points N_f in any fault group, the number of different rows involved in the fault group N_fr, the number of different columns involved in the fault group N_fc, the number of rows containing two or more fault points N_mr, and the number of columns containing two or more fault points N_mc.
[0025] Following the example above, perform BFS connectivity grouping on the remaining 93 fault points: Grouping results: A total of 17 independent fault groups were obtained, of which 12 were single fault groups containing only 1 fault point (S=12), and 5 were multi-fault groups containing 2 or more fault points (M=5).
[0026] Feature calculation example: Taking the multi-fault group numbered G3 as an example, this group contains 8 fault points, involving 4 rows and 3 columns. Statistics show: Total number of failure points N_f = 8; There are 4 rows in total, involving different rows, i.e., N_fr = 4; There are 3 columns involved, i.e., N_fc = 3; Each of the two rows contains ≥2 fault points, meaning the number of multi-fault rows N_mr = 2; One column contains ≥2 fault points, i.e., the number of multi-fault columns N_mc = 1.
[0027] Step 3: Pre-screen each fault group using basic quick verification rules. If the basic verification passes, proceed to Step 4; otherwise, the corresponding fault group is considered unrepairable, and the repair process ends. The basic quick verification rules include: Count the number of fault groups with a single fault (S), the number of fault groups with multiple faults (M), and the current remaining total repair resources (Total_spare = R_rem + C_rem). If Total_spare < S, it means that the corresponding fault group is unrepairable, and the memory repair process is terminated. If Total_spare = S and M > 0, it indicates that the corresponding fault group is unrepairable, and the memory repair process is terminated. If Total_spare ≥ S + M, it means that the corresponding fault group has passed the basic verification.
[0028] Following the above grouping results: The number of single-fault groups is S=12, the number of multi-fault groups is M=5; the remaining redundant rows are R_rem=32, the remaining redundant columns are C_rem=15, therefore the total repair resources Total_spare = 32 + 15 = 47.
[0029] Verification judgment: 47 ≥ 12 + 5 = 17, which satisfies the third passing condition. Therefore, the basic rule verification is passed, and we proceed to the next step of greedy matching lower bound estimation.
[0030] Step 4: As Figure 1 As shown, the lower bound of the redundant resource requirement needed for each pre-screened fault group is calculated using a greedy matching lower bound estimation algorithm. This lower bound is used to calculate the total global redundant resource requirement, thereby determining whether the memory fault matrix is repairable. If it is determined to be repairable, step 5 is executed; otherwise, the repair process ends. The greedy matching lower bound estimation algorithm includes: a. Initialize the current fault point set Current_Set to include all fault points in any fault group, and set the counter lower_bound=0; b. Calculate the row degree (deg_row), column degree (deg_col), and joint degree (joint_deg) of each fault point in the Current_Set: deg_row + deg_col; where deg_row is the total number of fault points contained in any fault row r' in the current remaining fault set, and deg_col is the total number of fault points contained in any fault column c' in the current remaining fault set.
[0031] c. Select the coordinates (r*, c*) of the fault point with the lowest degree of coherence; d. After assigning lower_bound+1 to lower_bound, remove the row and column containing the fault with the lowest degree of federation (r*, c*) from Current_Set.
[0032] e. Check if Current_Set is empty. If it is empty, it means that lower_bound is the lower bound of the resource requirement for this fault group; otherwise, return b. Step 4 determines whether each fault group is repairable according to the following steps: Calculate the sum of the lower bounds of the requirements for all fault groups. , where m is the total number of fault groups; This represents the lower bound of the resource requirements for the k-th fault group after pre-screening.
[0033] If Sum_min_total ≤ Total_spare, then the memory is considered repairable. If Sum_min_total > Total_spare, then the memory is considered unrepairable. Figure 3 The diagram shows a greedy matching lower bound estimation algorithm. Taking the fault group G3 mentioned above as an example, the greedy matching lower bound estimation algorithm is executed completely: Initial conditions: G3 has 8 fault points, distributed across 4 rows (row numbers 1024, 2048, 4096, 8192) and 3 columns (column numbers 128, 256, 512); row 1024 has 3 fault points, row 2048 has 2 fault points, row 4096 has 2 fault points, and row 8192 has 1 fault point; column 256 has 3 fault points, column 512 has 3 fault points, and column 128 has 2 fault points. First iteration: ① Initialize Current_Set to include all 8 fault points, lower_bound_k = 0.
[0034] ② Calculate the row degree, column degree, and joint degree of each fault point: Point (1024,128): deg_row=3, deg_col=2, joint_deg=5; Point (1024,256): deg_row=3, deg_col=3, joint_deg=6; Point (1024,512): deg_row=3, deg_col=3, joint_deg=6; Point (2048,256): deg_row=2, deg_col=3, joint_deg=5; Point (2048,512): deg_row=2, deg_col=3, joint_deg=5; Point (4096,256): deg_row=2, deg_col=3, joint_deg=5; Point (4096,512): deg_row=2, deg_col=3, joint_deg=5; Point (8192,128): deg_row=1, deg_col=2, joint_deg=3; ③ Select the point with the smallest joint degree (8192,128), which has a joint degree of 3.
[0035] ④ lower_bound is updated to 1; all fault points in row 8192 and column 128 are removed, clearing a total of 2 faults, leaving 6 fault points in Current_Set.
[0036] Second iteration: ① The Current_Set has 6 remaining fault points, involving 3 rows (1024, 2048, 4096) and 2 columns (256, 512).
[0037] ② Recalculate the degree of union of all points: the row degree of all points is 2, 2, 2, the column degree is 3, and the degree of union is 5.
[0038] ③ Choose any point with the smallest joint degree, for example (2048, 256).
[0039] ④ `lower_bound` is updated to 2; all fault points in row 2048 and column 256 are removed, clearing a total of 4 faults. `Current_Set` has 2 remaining fault points: (1024, 512) and (4096, 512). Third iteration: ① The Current_Set has 2 remaining fault points, both located on column 512.
[0040] ② Calculate the degree of union: The column degree of both points is 2, the row degree is 1, and the degree of union is 3.
[0041] ③ Select point (1024, 512).
[0042] ④ `lower_bound` is updated to 3; all fault points in row 1024 and column 512 are removed, and `Current_Set` is cleared. ⑤ `Current_Set` is empty, the iteration ends, and the lower bound of resource requirements for fault group G3 is `lower_bound` = 3. The above calculation is performed sequentially on the remaining four multi-fault groups, yielding lower bounds of 2, 2, 2, and 1 respectively; the lower bound for all 12 single-fault groups is 1.
[0043] The global lower bound sum Sum_min_total = 12×1 + (3+2+2+2+1) = 22.
[0044] The total available resources Total_spare=47, which satisfies 22 ≤ 47. Therefore, the fault matrix is theoretically repairable, and the subsequent solution generation process continues.
[0045] Step 5: Using a depth-first search combined with a branch and bound method, find the optimal repair solution from the candidate repair solutions of each fault group that satisfies the global resource constraints and minimizes the total repair cost, execute the solution, and then verify the repair results of the memory matrix.
[0046] Grouping scheme generation: Generate candidate repair schemes for each of the 17 fault groups, and retain 3-5 low-cost schemes for each group.
[0047] Global search: By traversing the combinatorial space using DFS combined with branch and bound techniques, the globally optimal repair solution is finally found: a total of 8 redundant rows and 5 redundant columns are consumed, with a total resource consumption of 13, which satisfies the remaining resource constraints.
[0048] Execution and verification: Row and column repairs were performed sequentially according to the plan. Finally, all fault points in the fault matrix were completely cleared, and the repair was successful.
[0049] In this embodiment, an early termination judgment system for memory array repair includes: The data preprocessing module is used to identify, perform, and update the status of items that must be repaired. The fault grouping module is used to group the remaining fault points based on connectivity and calculate the statistical characteristics of each group; The early termination judgment module is used to perform basic rule fast verification, greedy matching lower bound estimation, and global resource requirement determination; The early termination judgment module includes: The basic rule verification unit is used to perform rapid pre-screening based on the number of single fault groups, the number of multiple fault groups, and the total remaining resources. The lower bound estimation unit is used to calculate the lower bound of resource requirements for each fault group using a greedy matching algorithm. The global decision unit is used to determine whether a fault is repairable based on the sum of the lower bounds of all fault groups.
[0050] The repair scheme generation and execution module is used to generate candidate repair schemes, search for the optimal solution, and execute the repair operation; The results output module is used to output the repair results and related statistical information.
Claims
1. A method for early termination determination in memory array repair, characterized in that, Includes the following steps: Step 1: Obtain the memory fault matrix and make a judgment to obtain the fault rows and columns that must be repaired first, and repair them to obtain the repaired fault rows and columns as well as the remaining fault rows and columns. Step 2: Use a breadth-first search method based on row-column connectivity to group the fault points in the remaining fault rows and columns to obtain single-fault fault groups and multi-fault fault groups, and calculate the statistical characteristics of each fault group. Step 3: Pre-screen each fault group using basic quick verification rules. If the basic verification is passed, proceed to Step 4; otherwise, the corresponding fault group is considered unrepairable, and the repair process ends. Step 4: Calculate the lower bound of the redundancy resource requirements needed for each pre-screened fault group using a greedy matching lower bound estimation algorithm. This lower bound is used to calculate the total global redundancy resource requirements, thereby determining whether the memory fault matrix is repairable. If it is determined to be repairable, proceed to Step 5; otherwise, end the repair process. Step 5: Using a depth-first search combined with a branch and bound method, find the optimal repair solution from the candidate repair solutions of each fault group that satisfies the global resource constraints and minimizes the total repair cost, and then execute it.
2. The early termination determination method according to claim 1, characterized in that, Step 1 includes: The number of fault points F_c in fault column c of the fault matrix is counted. When F_c is greater than the number of remaining available redundant rows R_rem, fault column c is determined to be a fault column that must be repaired first. The number of fault points F_r in any fault row r of the fault matrix is counted. If F_r is greater than the number of remaining available redundant columns C_rem, then the fault row r is determined to be the fault row that must be repaired first.
3. The early termination determination method according to claim 1, characterized in that, The statistical characteristics of each fault group in step 2 include at least the following: the total number of fault points N_f in any fault group, the number of different fault rows involved in the fault group N_fr, the number of different fault columns involved in the fault group N_fc, the number of fault rows containing two or more fault points in the fault group N_mr, and the number of fault columns containing two or more fault points in the group N_mc.
4. The early termination determination method according to claim 2, characterized in that, Step 3 includes: Calculate the number of fault groups S containing a single fault point, the number of fault groups M containing multiple fault points, and the current remaining total repair resources Total_spare = R_rem + C_rem; If Total_spare < S, it means that the corresponding fault group is unrepairable, and the memory repair process is terminated. If Total_spare = S and M > 0, it indicates that the corresponding fault group is unrepairable, and the memory repair process is terminated. If Total_spare ≥ S + M, it means that the corresponding fault group has passed the basic verification.
5. The early termination determination method according to claim 4, characterized in that, The greedy matching lower bound estimation algorithm in step 4 includes: a. Initialize the current fault point set Current_Set to include all fault points in any pre-filtered fault group, and set the counter lower_bound=0; b. Calculate the row degree deg_row, column degree deg_col, and joint degree joint_deg = deg_row + deg_col for each fault point in Current_Set; where, row degree deg_row refers to the total number of fault points contained in any fault row r' in the current remaining fault set; column degree deg_col refers to the total number of fault points contained in any fault column c' in the current remaining fault set; c. Select the coordinates (r*, c*) of the fault point with the minimum cohesion; where r* represents the row coordinate of the fault point with the minimum cohesion, and c* represents the column coordinate of the fault point with the minimum cohesion. d. After assigning lower_bound+1 to lower_bound, remove the fault points in the row and column containing the fault point with the lowest degree of association from Current_Set; e. Determine if Current_Set is empty. If it is empty, it means that lower_bound is the lower bound of the resource requirements of the pre-filtered fault group. Otherwise, return to step b.
6. The early termination determination method according to claim 5, characterized in that, Step 4 involves determining whether the memory fault matrix is repairable using the following steps: Calculate the total global redundant resource requirements by summing the lower bounds of the requirements of all fault groups after pre-screening. , where m is the total number of fault groups after pre-screening; This represents the lower bound of the resource requirements for the kth fault group after pre-screening. If Sum_min_total ≤ Total_spare, then the memory fault matrix is determined to be repairable; If Sum_min_total > Total_spare, then the memory fault matrix is determined to be unrepairable.
7. An early termination judgment system for memory array repair, characterized in that, include: The data preprocessing module is used to obtain the fault matrix in memory and make a judgment, thereby repairing the fault rows and columns that must be repaired first, and updating the repair status in the fault matrix. The fault grouping module is used to group the fault points in the remaining fault rows and fault columns based on connectivity, and to calculate the statistical characteristics of each fault group. The early termination judgment module is used to perform basic rule fast verification, greedy matching lower bound estimation and global resource requirement judgment on each fault group, so as to determine whether the memory fault matrix is repairable. The early termination judgment module includes: The basic rule verification unit is used to pre-screen basic fast verification rules based on the number of fault groups for a single fault, the number of fault groups for multiple faults, and the total remaining resources. The lower bound estimation unit is used to calculate the lower bound of resource requirements for each fault group after pre-screening using a greedy matching algorithm, so as to obtain the total global redundant resource requirements. The global determination unit is used to determine whether the memory fault matrix is repairable based on the total global redundant resource requirements. The repair scheme generation and execution module is used to generate the optimal repair scheme from the repairable fault matrix and execute the repair operation.
