CN118133778A

CN118133778A - Failure point analysis method, device, computer equipment and storage medium

Info

Publication number: CN118133778A
Application number: CN202410552392.6A
Authority: CN
Inventors: 陈小川; 邵康鹏
Original assignee: Hangzhou Guangli Microelectronics Co ltd
Current assignee: Hangzhou Guangli Microelectronics Co ltd
Priority date: 2024-05-07
Filing date: 2024-05-07
Publication date: 2024-06-04

Abstract

The application relates to a failure point analysis method, a device, computer equipment and a storage medium, wherein the failure point analysis method comprises the following steps: traversing the data points of the test result row by row, determining failure type codes of the data points, and constructing a relation array; the relationship array represents: connection relations among the failure type codes; traversing each data point row by row again, and updating the failure type code of each data point according to the relation array; and according to the updated failure type codes, carrying out graphic display on the failure types of the data points. By adopting the method, the failure type coding efficiency of the data points of the test result is improved.

Description

Failure point analysis method, device, computer equipment and storage medium

Technical Field

The present application relates to the field of semiconductor data analysis technologies, and in particular, to a failure point analysis method, a failure point analysis device, a computer device, and a storage medium.

Background

With the development of integrated circuits in moore's law, memory banks are gradually developed, and the memory cell of one memory bank is a 01 inverter circuit. After the test, the memory bank needs to classify the failure type of each minimum storage unit, and the memory bank of 1GB corresponds to 10 hundred million storage small particles. Aiming at large-scale storage of small particles, the compositions of the failure points can be classified into different categories according to the shape and the size of the failure points, the problem points in the production process can be analyzed by analyzing the categories of the failure points, the production efficiency and the production stability can be improved, and the failure type conditions of the failure point compositions with the connection relation are required to be analyzed at present.

A common algorithm might be to traverse to a failure point and then traverse all remaining data points to find all failure points connected to the failure point, giving the same code. Traversing to the next unconnected failure point, traversing in the same way to find the failure point connected with the failure point, and giving a new code.

By adopting the method for traversing, if the method is realized in a recursive manner, the problem of stack overflow possibly caused by recursive call of the function can be solved, if the method is realized in other manners, the process of frequently pushing and popping the stack of data can be realized, the data points can be traversed for a plurality of times, the problem of high time complexity of an algorithm can be solved, and the failure type traversing efficiency of the data points in the memory bank can be influenced.

Disclosure of Invention

Based on the foregoing, it is necessary to provide a failure point analysis method, a device, a computer device and a storage medium capable of improving the failure type code analysis efficiency, so as to quickly and effectively perform cluster coding or cluster classification on the failure points, namely, classifying the failure storage small particles with a connection relationship into a failure type.

In a first aspect, the present application provides a method for analyzing a failure point, including:

Traversing the data points of the test result row by row, determining failure type codes of the data points, and constructing a relation array; the relationship array represents: connection relations among the failure type codes;

Traversing each data point row by row again, and updating the failure type code of each data point according to the relation array;

and according to the updated failure type codes, carrying out graphic display on the failure type of each data point.

In one embodiment, the determining the failure type code for each data point includes:

if the current data point is a non-failure point, determining-1 as a failure type code of the current data point;

If the current data point is a failure point, determining the failure type code of the current data point according to the failure type code of the adjacent data point of the current data point and/or the failure type code of the adjacent data point with a connection relation, or according to the current maximum failure type code.

In one embodiment, the determining the failure type code of the current data point according to the failure type code of the adjacent data point of the current data point and/or the failure type code of the adjacent data point with the connection relation, or according to the current maximum failure type code, includes:

if the adjacent data point has a failure point, determining the failure type code of the adjacent data point as the failure type code of the current data point, or determining the minimum failure type code of the adjacent data point and the failure type code with a connection relation with the adjacent data point as the failure type code of the current data point;

and if no failure point exists in the adjacent data points, determining the current maximum failure type code plus 1 as the failure type code of the current data point.

In one embodiment, the traversing the data points of the test result row by row, and determining the failure type code of each data point includes:

Constructing a first array, and recording failure type codes of traversed data points of the current traversal row;

Constructing a second array, and recording failure type codes of all data points of adjacent lines of the current traversal line as failure type codes for acquiring the adjacent data points;

And traversing the data points in the test result row by row, and storing each failure type code with a connection relation with the failure type code through a relation array.

In one embodiment, the traversing the data points in the test result row by row further includes:

And constructing a third array, traversing the data points in the test result row by row, and storing the number of the data points corresponding to each failure type code through the third array.

In one embodiment, the traversing the data points of the test result row by row, and determining the failure type code of each data point further includes:

Traversing all data points of a first row in sequence, determining failure type codes of all data points in the first row, and storing the failure type codes to corresponding positions of a first array respectively;

copying the failure type codes of all the data points in the first array to the second array, and deleting the failure type codes of all the data points in the first array;

Traversing all data points of the next row based on the first array, determining failure type codes of all data points in the next row, and respectively storing the failure type codes to corresponding positions of the first array; copying the failure type codes of all the data points in the first array to the second array, and deleting the failure type codes of all the data points in the first array; until the traversal is completed for each row of data points in the test result.

In one embodiment, the sequentially traversing all data points in the first row, determining the failure type encoding for each data point in the first row includes:

If the current data point is a failure point and a failure point exists in the adjacent data points, determining the failure type code of the adjacent data points as the failure type code of the current data point;

if the current data point is a failure point and no failure point exists in the adjacent data points, the current maximum failure type code is added with 1 to be determined as the failure type code of the current data point.

In one embodiment, the traversing all data points in the next row, determining the failure type encoding for each data point in the next row includes:

If the current data point is a failure point and the adjacent data point has a failure point, acquiring a failure type code of the adjacent data point, acquiring a failure type code with a connection relation with the adjacent data point through a relation array, acquiring a minimum failure type code from the failure type code to determine the failure type code of the current data point, and updating the failure type code with the connection relation of the adjacent data point into the minimum failure type code in the relation array;

In one embodiment, the adjacent data point refers to the previous digit of the current data point, and the data points in the previous row at positions corresponding to the current data point and the previous digit of the current data point.

In one embodiment, the traversing each data point row by row again, updating the failure type code of each data point according to the relation array, includes:

acquiring the minimum failure type codes of each failure type code and the connection relation between the minimum failure type codes and the minimum failure type codes through the relation array;

Traversing the data points of the test result row by row, determining initial failure type codes of the data points, acquiring minimum failure type codes corresponding to the initial failure type codes according to the relation array, and taking the minimum failure type codes as the failure type codes corresponding to the data points.

In a second aspect, the present application also provides a failure point analysis apparatus, including:

the first traversing module is used for traversing the data points of the test result row by row, determining the failure type codes of the data points and constructing a relation array; the relationship array represents: connection relations among the failure type codes;

The second traversing module is used for traversing each data point row by row again, and updating the failure type code of each data point according to the relation array;

And the graphic display module is used for graphically displaying the failure type of each data point according to the updated failure type code.

In a third aspect, the present application also provides a computer device comprising a memory storing a computer program and a processor implementing the steps of the method of any one of the first aspects when the computer program is executed by the processor.

In a fourth aspect, the present application also provides a computer-readable storage medium having stored thereon a computer program which, when executed by a processor, implements the steps of the method of any of the first aspects.

The failure point coding method, the failure point coding device, the computer equipment and the storage medium are used for traversing the data points of the test result line by line, determining the failure type codes of the data points and constructing a relation array; the relation array represents: connection relations among the failure type codes; traversing each data point row by row again, and updating the failure type code of each data point according to the relation array; and according to the updated failure type codes, carrying out graphic display on the failure types of the data points. The failure type codes of the data points are obtained through twice traversal, the failure type codes of the data points are updated, adjacent failure points are updated to be the same failure type codes by utilizing the relation array, the failure point clustering codes can be completed without multiple traversal, and the efficiency of the failure type codes of the data points in the storage unit is improved.

Drawings

In order to more clearly illustrate the embodiments of the present application or the technical solutions in the related art, the drawings that are required to be used in the embodiments or the related technical descriptions will be briefly described, and it is apparent that the drawings in the following description are only some embodiments of the present application, and other drawings may be obtained according to the drawings without inventive effort for those skilled in the art.

FIG. 1 is a diagram of an application environment for a method of point of failure analysis in one embodiment;

FIG. 2 is a schematic diagram of a graphical display of failure types for data points in one embodiment;

FIG. 3 is a diagram of failure type encoding of data points in a memory cell in one embodiment;

FIG. 4 is a flow diagram of determining failure type encoding for each data point in one embodiment;

FIG. 5 is a flow chart of determining failure type encoding for each data point in a first row by sequentially traversing all data points in the first row in one embodiment;

FIG. 6 is a flow diagram of updating a failure type code for each data point in one embodiment;

FIG. 7 is a schematic diagram of data points of a memory cell prior to point of failure encoding in one embodiment;

FIG. 8 is a block diagram of a point of failure analysis apparatus in one embodiment;

fig. 9 is an internal structural diagram of a computer device in one embodiment.

Detailed Description

The present application will be described in further detail with reference to the drawings and examples, in order to make the objects, technical solutions and advantages of the present application more apparent. It should be understood that the specific embodiments described herein are for purposes of illustration only and are not intended to limit the scope of the application.

In an exemplary embodiment, as shown in fig. 1, a method for analyzing a failure point is provided, where this embodiment is applied to a terminal for illustration, it is understood that the method may also be applied to a server, and may also be applied to a system including a terminal and a server, and implemented through interaction between the terminal and the server. In this embodiment, the method includes the following steps 102 to 106. Wherein:

Step 102, traversing the data points of the test result row by row, determining the failure type code of each data point, and constructing a relation array.

In this embodiment, the test result is an exemplary memory unit, where the memory unit includes a plurality of rows and columns of data points, and failure type codes of each data point can be obtained by traversing the data points, so as to complete failure clustering classification of the data points. The relationship array represents the connection relationship between each failure type code.

Specifically, each row of data points in the memory unit is traversed, whether each data point is a failure point is determined, the same failure type code is assigned to all non-failure points in the data points, and for each failure point, the failure type code is determined according to whether the failure point is adjacent to other failure points.

Step 104, traversing each data point row by row again, and updating the failure type code of each data point according to the relation array.

Specifically, traversing each data point row by row again to obtain failure type codes of each data point, and updating the failure type codes of each data point according to the relationship among the failure type codes in the relationship array and the minimum failure type codes.

Illustratively, if a certain data point is a failure point, its failure type code is 3, and the minimum failure type code having a connection relationship with the failure type code 3 in the relationship array is 1, the failure type code of the data point is updated to be 1.

And 106, graphically displaying the failure type of each data point according to the updated failure type codes.

Specifically, according to the updated failure type code, different colors are adopted for graphic display of the areas where the failure points and the non-failure points in the storage unit are located.

Illustratively, as shown in FIG. 2, FIG. 2 is a schematic diagram that graphically displays failure types for each data point in one embodiment. The second line of data points is a failure point obtained through traversing, and the area where the line of data points is located is graphically displayed by adopting different colors from the non-failure point.

In the method of the embodiment, data points of a test result are traversed row by row, failure type codes of the data points are determined, and a relation array is constructed; the relation array represents: connection relations among the failure type codes; traversing each data point row by row again, and updating the failure type code of each data point according to the relation array; and according to the updated failure type codes, carrying out graphic display on the failure types of the data points. The method comprises the steps of traversing line by line and endowing codes, combining relation arrays for recording the connection relation of the codes, traversing twice to obtain failure type codes of all data points, updating the connected failure points into the same failure type codes, avoiding the conventional method (traversing to one failure point, then traversing all the remaining data points to find all the failure points connected with the failure point and endowing the same codes), wherein each failure point needs to be traversed once, multiple traversal is not needed, and failure point clustering coding analysis can be completed, so that the efficiency of failure type codes of data points in a storage unit is improved.

In one exemplary embodiment, determining the failure type encoding for each data point includes: if the current data point is a non-failure point, determining-1 as a failure type code of the current data point; if the current data point is a failure point, determining the failure type code of the current data point according to the failure type code of the adjacent data point of the current data point and/or the failure type code of the adjacent data point with a connection relation, or according to the current maximum failure type code.

Wherein, according to the failure type code of the adjacent data point of the current data point and/or the failure type code of the adjacent data point with the connection relation, or according to the current maximum failure type code, determining the failure type code of the current data point comprises: if the adjacent data point has a failure point, determining the failure type code of the adjacent data point as the failure type code of the current data point, or determining the minimum failure type code of the adjacent data point and the failure type code with a connection relation with the adjacent data point as the failure type code of the current data point; if no failure point exists in the adjacent data points, the current maximum failure type code is added with 1 to be determined as the failure type code of the current data point, and the specific determination mode is determined according to the traversal row.

For example, as shown in fig. 3, fig. 3 is a schematic diagram of failure type codes of data points in a memory unit when the data points in the memory unit are not updated according to the relation array after the data points in the memory unit are traversed line by line for the first time. Wherein the data point of the first row and the first column is a failure point, the failure type code is 1, and when traversing to the data point of the second row and the second column, the minimum failure type code of the failure point in the adjacent data points is 1, so that the failure type code is determined to be 1. When traversing to the fifth column of the first row, the data point is a failure point, but no failure point exists in the adjacent data points, so that 1 is added on the basis of the current maximum failure type code 1, and 2 is determined as the failure type code of the data point.

In this embodiment, if the current data point is a non-failure point, then determining-1 as the failure type code of the current data point; if the current data point is a failure point, determining the failure type code of the current data point according to the failure type code of the adjacent data point of the current data point and/or the failure type code of the adjacent data point with a connection relation, or according to the current maximum failure type code. Corresponding failure type codes are determined for the non-failure points and the failure points respectively, so that the failure type codes of all the data points and the corresponding code relation with the connection relation can be obtained, further traversal is conducted, the codes of all the failure points are determined, and finally the failure type codes of all the data points are obtained.

In one exemplary embodiment, as shown in FIG. 4, traversing the data points of the test result (memory cell) row by row, determining the failure type code for each data point includes steps 402 through 406. Wherein:

step 402, constructing a first array, and recording failure type codes of traversed data points of a current traversal row.

The first array is an array with the same length as the column number of the data points in the memory unit.

Illustratively, the first array is an array a having eight elements, and the first row of data points in the memory unit shown in fig. 3 is traversed by the first array a to obtain the failure type codes of the data points and store the failure type codes into the corresponding positions of the array to obtain a (1, -1,2, -1, -1).

Step 404, constructing a second array, and recording the failure type codes of all data points of adjacent lines of the current traversal line as the failure type codes for acquiring the adjacent data points.

The second array is an array with the same length as the column number of the data points in the memory unit.

Illustratively, the invalidation type code held in the first array A (1, -1,2, -1, -1) is copied to the second array B, B (1, -1,2, -1, -1) is obtained and all elements in array A are deleted.

Step 406, traversing the data points in the test result row by row, and storing each failure type code with a connection relation with the failure type code through a relation array.

The relation array is a dynamic variable array, and the length of the relation array is the same as the number of connection relations between failure type codes of failure points obtained by current traversal.

For example, the data point of the first column of the fourth row is a failure point with a failure type code of 3, the corresponding element in the relation array D is D [3] = -1, when traversing to the data point of the second column of the fourth row, the failure type code of the adjacent data point can be obtained, that is, the failure type code of the first column of the third row is 3, the failure type code of the third column of the third row is 1, that is, the minimum failure type code of the adjacent failure point is 1, that is, the minimum failure type code is 1 is given to the data point of the second column of the fourth row, then the failure type code 1 and the failure type code 3 have a connection relation, and then D [3] = -1 in the relation array D is updated as D [3] = -1.

In the embodiment, a first array is constructed, and failure type codes of traversed data points of a current traversal row are recorded; constructing a second array, and recording failure type codes of all data points of adjacent lines of the current traversal line as failure type codes for acquiring the adjacent data points; and traversing the data points in the test result row by row, and storing each failure type code with a connection relation with the failure type code through a relation array. When the method of the embodiment is adopted to traverse data points, each row of data points is traversed through the first array, and failure type codes of data points of adjacent rows can be saved through the second array, so that the failure type codes of current data points can be determined according to the failure type codes of adjacent data points of the currently traversed data points, and the connection relation among different failure type codes can be obtained. By constructing the relation array, the connection relation among the data points of different failure type codes can be obtained, so that the failure type codes of adjacent failure points can be directly updated to the same failure type codes during the secondary traversal, and the clustering analysis of the failure point failure types can be completed.

In an exemplary embodiment, as shown in fig. 5, on the basis of traversing the data points in the test result row by row based on the above embodiment, there is further provided a method for determining failure type codes of the data points, including:

Step 502, traversing all data points in the first row in turn, determining failure type codes of all data points in the first row, and storing the failure type codes to corresponding positions of the first array respectively.

Specifically, if the current data point is a failure point and a failure point exists in the adjacent data points, determining the failure type code of the adjacent data points as the failure type code of the current data point; if the current data point is a failure point and no failure point exists in the adjacent data points, the current maximum failure type code is added with 1 to be determined as the failure type code of the current data point.

Wherein the adjacent data points are different according to the different traversed rows, specifically, when traversing the first row, the adjacent data points refer to the previous bit of the current data point; when traversing a non-first row, adjacent data points refer to the previous digit of the current data point and 3 data points in the previous row corresponding to the current data point, the previous digit of the current data point, and the next digit data point.

Step 504, copy the failure type code of each data point in the first array to the second array, and delete the failure type code of each data point in the first array.

Step 506, traversing all data points of the next row based on the first array, determining failure type codes of each data point in the next row, and storing the failure type codes to corresponding positions of the first array respectively; copying the failure type codes of all the data points in the first array to the second array, and deleting the failure type codes of all the data points in the first array; until the traversal is completed for each row of data points in the test result.

In an exemplary embodiment, performing the row-by-row traversal of the data points in the memory cells further includes constructing a third array, and maintaining the number of data points corresponding to each failure type code through the third array while performing the row-by-row traversal of the data points of the test result.

The third array is a dynamic variable array, and the length of the third array is the same as the number of failure type codes of the failure points obtained by current traversal.

Illustratively, when traversing to the first row and second column of data points, the third array C has a length of 1, C1 = 2, indicating that there are two data points corresponding to failure type code 1. When traversing to the fifth column of data points of the first row, the third array C has a length of 2, C1=2 (two data points corresponding to failure type code 1), and C2=1 (1 data point corresponding to failure type code 2).

In this embodiment, a third array is constructed, and the number of data points corresponding to each failure type code is saved by the third array when the data points in the memory unit are traversed row by row. By constructing the third array, the number of data points corresponding to each failure type code can be obtained, and the subsequent analysis processing of the failure type corresponding to the failure type code is facilitated, for example, a threshold value of the number of clusters is set, and clusters lower than the threshold value are not subjected to visual display analysis.

In one exemplary embodiment, as shown in FIG. 6, the data points are traversed again row by row, and the failure type code for each data point is updated according to the relationship array, including steps 602 through 604. Wherein:

step 602, obtaining the minimum failure type code of each failure type code and the minimum failure type code with connection relation through the relation array.

Illustratively, D [1] = 1 is obtained by the relation array, representing that the minimum failure type code of the data point adjacent to failure type code 1 is 1, D [2] = 2, representing that the minimum failure type code of the data point adjacent to failure type code 2 is 2. D3=1, indicating that the minimum failure type code for a failure type code 3 neighboring data point is 1.

Step 604, traversing the data points of the test result row by row, determining an initial failure type code of each data point, acquiring a minimum failure type code corresponding to the initial failure type code according to the relation array, and taking the minimum failure type code as the failure type code corresponding to the data point.

For example, according to the encoding rule, the failure type of the data point in the fourth row and the first column in the memory unit is encoded as 3, the first traversal has obtained that the encoding 3 and the encoding 1 have a connection relationship, and the encoding 1 is the minimum failure type encoding, then the minimum failure type encoding of the data point is encoded as 1, and then the failure type encoding corresponding to the data point is updated as 1 in the second traversal.

In the embodiment, acquiring the minimum failure type code of each failure type code and the minimum failure type code with a connection relation of the minimum failure type code through a relation array; traversing the data points of the test result row by row, determining initial failure type codes of the data points, acquiring minimum failure type codes corresponding to the initial failure type codes according to the relation array, and taking the minimum failure type codes as the failure type codes corresponding to the data points. The failure type codes of the data points are updated in the mode, the same failure type codes can be given to clusters of adjacent failure points in the second traversal, a new cluster with a connection relationship is formed, the failure point cluster codes are completed through the two traversals, and the efficiency of the failure type codes of the data points in the storage unit is improved.

In an exemplary embodiment, the failure point analysis method of the present application is implemented using the following algorithm steps:

Firstly, the data pattern of the result of the failure point coding is a square or rectangle with a plurality of rows and a plurality of columns as shown in fig. 2, the algorithm carries out twice traversal on data points in a memory unit to realize cluster classification and graphic display of the failure points, each traversal uses each row of data as a node to carry out line-by-line traversal, the first traversal realizes connection relation construction on each code through cooperation of a plurality of arrays, the second traversal directly updates a plurality of codes with different sizes with connection relations into the same code according to the connection relation among the codes obtained by the first traversal according to the same traversal rule, classifies a plurality of failure points which are sequentially connected into a cluster, and the corresponding failure points are marked to finish the final classification.

The first traversal operation is as follows:

Firstly, creating an array A and an array B, wherein the lengths of the two arrays are the widths of pictures of a memory unit, namely the lengths of one row of data points of a test result, and the array A and the array B are the failure point conditions of recording one row of data points, the difference is that the array A records the failure point conditions of the current row of data points, the array B records the failure point conditions of the last row of data points, if the codes of non-failure points are-1, the codes of the failure points are possibly 1,2, 3 and the like according to whether the continuous conditions exist, the codes of the non-continuous failure points are different, and the assignment of the failure point codes of the data points of different rows is determined according to the maximum coding value in front of the current row.

Secondly, creating a dynamic variable array C and a dynamic variable array D, wherein the array C records the number of data points of the cluster type corresponding to each code, and the array D records the connection relation between the data points of the cluster type corresponding to each code;

Third, traversing the first row of data points, and judging whether the current data point is fail or pass (non-fail);

in case 1, if the current data point is pass, the tag code is-1 at the column number position of the array A corresponding to the current data point;

Case 2, if the current data point is fail, needs to determine what code is the point before the current data point, specifically including:

if the previous bit has no failure type code, then the code of array A at the column number position corresponding to the current data point is 1, the value of C [ code ] is +1, i.e., C [1] = 1;

If there is a failure type code in the previous bit and the failure type code is not-1 (i.e., the previous bit is a failure point), then the failure type code of array A at the column number position corresponding to the current data point is the same as the failure type code of the previous bit data point, and the value of C [ code ] is +1 (the value is 1, i.e., the number of failure points corresponding to the failure type code of the previous bit data point is 1), the value of D [ code ] is-1, the failure type codes corresponding to array C and array D are the failure type code of the previous bit, otherwise, the corresponding failure points need to generate new failure type codes, and the code value is the existing maximum code value +1 (the first failure point code value is 1, i.e., if it is the first failure point, the code value is 1);

fourth step: copying the value of the array A to the array B, and clearing the data of the array A;

fifth step: traversing the data points of the N line (namely traversing the second line and the data points behind the second line, wherein traversing the first line data points and other line data points are different traversing rules in the scheme), and judging whether the current data point is fail or pass;

In case 1, if the current data point is pass, filling-1 on the column number corresponding to the array A;

case 2, if the current data point is fail, assuming the current data point is the j-th bit, finding the minimum value (code A [ j-1 ]) of the failure point code of A [ j-1] and the failure type code connected with the failure point code through the D array; the D array is used to find out the corresponding failure point codes of Bj-1, bj, bj+1 and the minimum failure point codes (codes Bj-1, bj, bj+1) of the failure point codes connected with the corresponding failure point codes.

Comparing codes A [ j-1], codes B [ j ], codes B [ j+1], and adding the minimum codes to the current point codes, namely filling the current codes on the corresponding columns in the A array, updating codes A [ j-1], codes B [ j ], codes B [ j+1], and changing the minimum codes of the continuous codes, namely D [ codes ], into the minimum codes in the continuous codes, and meanwhile, the value of C [ codes ] is +1.

If the codes A [ j-1], B [ j ], and B [ j+1] are all-1 around the current point, the failure type code of the current point is the maximum failure type code +1;

sixth step: updating the value of the array A into the array B, and so on to complete the traversal of each line of data points.

The second traversal operation is as follows:

The step of the first traversal can traverse how many failure point clusters exist, and the connection relation among the failure point clusters; and repeating the first step of operation, sequentially judging the failure type code of the current point, and updating the current point into the numerical value in the D code.

The method of the embodiment is adopted to perform failure point coding, and only the small arrays A and B and the controllable dynamic arrays C and D are needed to be created. And traversing the pictures for two times to finish the cluster coding of the failure points. And each time the judging process is executed, the data points are operated by only taking the array subscripts, and the process is faster in the CPU processing process.

In an exemplary embodiment, by using the failure point analysis method of the present application, the memory cells of four rows and eight columns shown in fig. 7 are traversed to obtain the failure point cluster coding result shown in fig. 3, which includes the following steps:

Step S1, traversing the data points in the memory unit row by row, determining failure type codes of the data points, and constructing a relation array. The method specifically comprises the following steps:

Step S11, traversing the first row.

1. When traversing the first column, the current data point is the failure point and no failure point is the first failure point, and then the failure type code of the current data point is 1, and then the first array A (1,,,,) and the element C1 corresponding to the failure type code 1 in the third array C are=1, and the value of the element D1 corresponding to the failure type code 1 in the relation array D is a default value-1, which indicates that the failure point corresponding to the failure type code 1 has no adjacent failure point.

2. When traversing the second column, the current data point is a failure point, it is known that the failure type code exists in the previous adjacent data point and the failure type code is 1 (i.e. the failure type code is non-1), the failure type code of the current data point is the same as the failure type code of the previous one bit according to the traversing rule, namely 1, the first array a is updated to be an array a (1,,, the value of the third array C [ failure type code ] is +1, the value of the relation array D [ failure type code ] is-1, which indicates that the failure point corresponding to the failure type code has no adjacent failure point, and then the array C [1] = 2, D [1] = -1.

3. When traversing the third column and the fourth column, the current data point is a non-failure point, the first array A is updated to be an array A (1, -1, -1,,) and the third array C and the relation array D are not updated;

4. When traversing the fifth column, the current data point is a failure point, knowing that failure type codes exist in the non-adjacent data points before and the failure type codes are 1, and according to the traversing rule, the failure type codes of the current data point are the current maximum failure type code value +1, the current maximum failure type code value is 1, the failure type codes of the current data point are 2, and the first array A is updated to be the first array A (1, -1,2,); a third array C [1] =2, C [2] =1; relation array d1= -1, d2= -1.

5. The sixth to eighth columns are traversed in the same way, and the following groups are obtained:

a first array A (1, -1,2, -1, -1);

A third array C [1] =2, C [2] =2;

Relation array d1= -1, d2= -1.

Copying the value of the first array A to the second array B, and clearing the data of the first array A to obtain the following steps:

a second group B (1, -1,2, -1, -1);

A third array C [1] =2, C [2] =2;

Relation array d1= -1, d2= -1.

Step S12, traversing the second row.

1. When traversing the first column, the current data point is a non-failure point, the failure type is encoded as-1, then the first array A (-1,,,,) is used.

2. When traversing the second column, the current data point is the failure point, the following procedure is required:

① Acquiring a failure type code (-1) of a neighboring data point of the previous column of the current row, wherein the failure type code (-1) is a non-failure point;

② Obtaining failure type codes (1, 1 and 1 respectively) of a first column, a second column and a third column from a second array B, knowing that the first column and the second column of the previous row are failure points, and only obtaining the failure type code of the adjacent failure point, namely the minimum failure type code, of the failure type code 1 from the failure type codes A [ j-1], the failure type codes B [ j ] and the failure type codes B [ j+1] of adjacent data points, updating the failure type code 1 to the first array A, and updating the first array A (-1,,,) to the relation array D to D [1] =1; the value of C1 is +1, i.e. C1=3;

At this time, the array is updated as follows:

A first array A (-1,,,);

a second group B (1, -1,2, -1, -1);

a third array C [1] =3, C [2] =2;

Relation array D [1] =1, d2= -1.

3. When traversing the third through six columns, the current data points are all non-failure points, the failure type codes are all-1, and then the first array A (-1, -1, -1, -1,);

a second group B (1, -1,2, -1, -1);

a third array C [1] =3, C [2] =2;

Relation array D [1] =1, d2= -1.

4. When traversing the seventh and eighth columns in the same way, the following can be obtained:

a first array A (-1, -1, -1, -1,2, -1);

a second group B (1, -1,2, -1, -1);

a third array C [1] =3, C [2] =3;

Relation array D [1] =1, D [2] =2.

a second group B (-1, -1, -1, -1,2, -1);

a third array C [1] =3, C [2] =3;

Relation array D [1] =1, D [2] =2.

Step S13, traversing the third row.

The traversal is the same as the second row, and the following arrays can be obtained in the same way:

a first array A (-1, -1,2, -1);

a second group B (-1, -1, -1, -1,2, -1);

a third array C [1] =5, C [2] =4;

Relation array D [1] =1, D [2] =2.

a second group B (-1, -1,2, -1);

a third array C [1] =5, C [2] =4;

Relation array D [1] =1, D [2] =2.

Step S14, traversing the fourth row.

1. When traversing the first column, the current data point is the failure point, the following procedure is required:

because the data point is the first column of the fourth row, if there is no data point in the front, the failure type codes of the adjacent data points are obtained from the second array B, namely, the failure type codes of the first column and the second column (respectively, -1), the first column and the second column of the front row are both non-failure points, if there is no failure point in the adjacent data point, the failure type code of the current data point is the largest failure type code +1, and if the current largest failure type code is 2, the failure type code of the data point is 3, and at the moment, the array is updated as follows:

a first array a (3,,,,);

a second group B (-1, -1,2, -1);

a third array C [1] =5, C [2] =4, C [3] =1;

relation array D [1] =1, D [2] =2, D [3] = -1.

① Acquiring the failure type code of the first column A1 of the current row as 3, wherein the failure type code is A1=3;

② Acquiring failure type codes (respectively-1, 1) of data points (B1, B2, B3) of a first column, a second column and a third column of the previous row from a second array B, knowing that the first column and the second column of the previous row are non-failure points, and finding out the connection relation of the failure type code 1 from a relation array D (namely, the relation array D1=1) if only the failure type code 1 of the third column is the failure point, namely, the failure type code B2 is 1;

From failure type code A [1], failure type code B [2], failure type code B [3] from two failure point failure type codes of failure type code 1 and failure type code 3 which can be obtained, the minimum failure point failure type code is 1, the failure type code 1 is updated to the first array A, the first array A (3, 1,,,,) and the relation array D is updated to D [3] =1; the value of C1 is +1, i.e. C1=6; at this time, the array is updated as follows:

a first array a (3, 1,,,);

a second group B (-1, -1,2, -1);

a third array C [1] =6, C [2] =4, C [3] =1;

Relation array D [1] =1, D [2] =2, D [3] =1.

3. When traversing the third to eighth columns in the same manner, the following can be obtained:

a first array A (3, 1, -1, -1, -1,2, -1, -1);

a second group B (-1, -1,2, -1);

A third array C [1] =6, C [2] =5, C [3] =1;

Relation array D [1] =1, D [2] =2, D [3] =1.

a second group B (3, 1, -1, -1, -1,2, -1, -1);

A third array C [1] =6, C [2] =5, C [3] =1;

relation array D [1] =1, D [2] =2, D [3] =1;

The following figure situation is available:

step S2, traversing each data point row by row again, and updating the failure type code of each data point according to the relation array.

The first traversal is completed, the connection relation among different failure type codes can be obtained through the relation array D, the second traversal is carried out, the marking of the data points is completed, in the marking process, the failure type code of the current data point is judged in sequence, and meanwhile, the failure type code of the data point is updated according to the value of the element D [ i ] corresponding to the failure type code of the current data point in the relation array D.

If the failure type code obtained by the first traversal is 3, then the failure type code 3 of the point is updated to 1 according to the relation array D [3] =1 in the second traversal, and two clusters of the mark 1 and the mark 2 can be obtained at this time, if there are data points in the following sequence, the failure type code 1 and the failure type code 2 can be connected, and then after the second traversal is completed, the marks of the original failure type code 1 and the failure type code 2 are both 1.

It should be noted that, in the above manner, the clustering analysis of the failure point is completed through two traversals, only one traversals can be performed in fact, that is, the marking is performed during the first traversals, but the result needs to be stored or updated after each judgment, the requirements on data storage and calculation efficiency are large, especially the number of memory banks in the semiconductor industry is large, if the processing difficulty is greatly increased, such as the situation that the original failure type code 1 and the failure type code 2 are not connected, and the connection relationship between the failure type code 1 and the failure type code 2 can be formed by one failure point, then the original failure type code 1 and the failure type code 2 are required according to the requirement, the failure type code of the failure point should be 1, and if the data of the failure type code 2 is large, the marking is very troublesome to update.

It should be understood that, although the steps in the flowcharts related to the embodiments described above are sequentially shown as indicated by arrows, these steps are not necessarily sequentially performed in the order indicated by the arrows. The steps are not strictly limited to the order of execution unless explicitly recited herein, and the steps may be executed in other orders. Moreover, at least some of the steps in the flowcharts described in the above embodiments may include a plurality of steps or a plurality of stages, which are not necessarily performed at the same time, but may be performed at different times, and the order of the steps or stages is not necessarily performed sequentially, but may be performed alternately or alternately with at least some of the other steps or stages.

Based on the same inventive concept, the embodiment of the present application further provides a failure point analysis apparatus 800 for implementing the above-mentioned failure point analysis method. The implementation of the solution provided by the device is similar to that described in the above method, so the specific limitations of the embodiment of the one or more failure point analysis devices 800 provided below can be referred to above for the limitation of the failure point analysis method, and will not be repeated here.

In one exemplary embodiment, as shown in fig. 8, there is provided a point of failure analysis apparatus 800 comprising: a first traversal module 801, a second traversal module 802, and a graphical display module 803, wherein:

The first traversing module 801 is configured to traverse data points of a test result row by row, determine failure type codes of the data points, and construct a relationship array; the relation array represents: connection relations among the failure type codes;

a second traversing module 802, configured to traverse each data point row by row again, and update the failure type code of each data point according to the relation array;

The graphic display module 803 is configured to graphically display the failure type of each data point according to the updated failure type code.

The failure point analysis device 800 obtains the failure type codes of the data points through two traversals, updates the failure type codes of the data points, updates the adjacent failure points to the same failure type codes by using the relation array, can complete the failure point clustering codes without traversing for many times, and improves the efficiency of the failure type codes of the data points in the storage unit.

In one exemplary embodiment, the first traversal module 801 is further configured to determine a failure type encoding for each data point, including:

In one exemplary embodiment, the first traversing module 801 is further configured to determine, if there is a failure point in the neighboring data point, a failure type code of the neighboring data point as a failure type code of the current data point, or determine, as a failure type code of the current data point, a minimum failure type code of a failure type code of the neighboring data point and a failure type code having a connection relationship with the neighboring data point;

if no failure point exists in the adjacent data points, the current maximum failure type code is added with 1 to be determined as the failure type code of the current data point.

In one exemplary embodiment, the first traversal module 801 is further configured to construct a first array, and record a failure type code of a traversed data point of a current traversal row;

In one exemplary embodiment, the first traversing module 801 is further configured to construct a third array, and store, through the third array, the number of data points corresponding to each failure type code when traversing the data points in the test result row by row.

In one exemplary embodiment, the first traversing module 801 is further configured to sequentially traverse all data points in the first row, determine failure type codes of each data point in the first row, and store the failure type codes to corresponding positions of the first array respectively;

In one exemplary embodiment, the first traversing module 801 is further configured to determine, if the current data point is a failure point and there is a failure point in the neighboring data point, a failure type code of the neighboring data point as the failure type code of the current data point;

In one exemplary embodiment, the first traversing module 801 is further configured to obtain a failure type code of an adjacent data point if the current data point is a failure point and there is a failure point in the adjacent data point, obtain a failure type code of a connection relationship with the adjacent data point through a relationship array, obtain a minimum failure type code therefrom to determine the failure type code of the current data point, and update the failure type code of the connection relationship with the adjacent data point in the relationship array to the minimum failure type code;

In one exemplary embodiment, adjacent data points refer to the previous digit of the current data point and the data points in the previous row that correspond to the current data point, the previous digit of the current data point, and the next digit of the current data point.

In one exemplary embodiment, the second traversal module 802 is further configured to obtain, through the relation array, a minimum failure type code with which each failure type code has a connection relation;

In one exemplary embodiment, the second traversal module 802 is further configured to obtain, through the relational array, a minimum failure type code with which each failure type code has a connection relationship;

The various modules in the failure point analysis apparatus 800 described above may be implemented in whole or in part by software, hardware, or a combination thereof. The above modules may be embedded in hardware or may be independent of a processor in the computer device, or may be stored in software in a memory in the computer device, so that the processor may call and execute operations corresponding to the above modules.

In an exemplary embodiment, a computer device, which may be a terminal, is provided, and an internal structure thereof may be as shown in fig. 9. The computer device includes a processor, a memory, an input/output interface, a communication interface, a display unit, and an input means. The processor, the memory and the input/output interface are connected through a system bus, and the communication interface, the display unit and the input device are connected to the system bus through the input/output interface. Wherein the processor of the computer device is configured to provide computing and control capabilities. The memory of the computer device includes a non-volatile storage medium and an internal memory. The non-volatile storage medium stores an operating system and a computer program. The internal memory provides an environment for the operation of the operating system and computer programs in the non-volatile storage media. The input/output interface of the computer device is used to exchange information between the processor and the external device. The communication interface of the computer device is used for carrying out wired or wireless communication with an external terminal, and the wireless mode can be realized through WIFI, a mobile cellular network, NFC (near field communication) or other technologies. The computer program is executed by a processor to implement a failure point analysis method. The display unit of the computer device is used for forming a visual picture, and can be a display screen, a projection device or a virtual reality imaging device. The display screen can be a liquid crystal display screen or an electronic ink display screen, and the input device of the computer equipment can be a touch layer covered on the display screen, can also be a key, a track ball or a touch pad arranged on the shell of the computer equipment, and can also be an external keyboard, a touch pad or a mouse and the like.

It will be appreciated by persons skilled in the art that the architecture shown in fig. 9 is merely a block diagram of some of the architecture relevant to the present inventive arrangements and is not limiting as to the computer device to which the present inventive arrangements are applicable, and that a particular computer device may include more or fewer components than shown, or may combine some of the components, or have a different arrangement of components.

In an embodiment, there is also provided a computer device comprising a memory and a processor, the memory having stored therein a computer program, the processor implementing the steps of the method embodiments described above when the computer program is executed.

In one embodiment, a computer-readable storage medium is provided, on which a computer program is stored which, when executed by a processor, carries out the steps of the method embodiments described above.

In an embodiment, a computer program product is provided, comprising a computer program which, when executed by a processor, implements the steps of the method embodiments described above.

Those skilled in the art will appreciate that implementing all or part of the above described methods may be accomplished by way of a computer program stored on a non-transitory computer readable storage medium, which when executed, may comprise the steps of the embodiments of the methods described above. Any reference to memory, database, or other medium used in embodiments provided herein may include at least one of non-volatile and volatile memory. The nonvolatile Memory may include Read-Only Memory (ROM), magnetic tape, floppy disk, flash Memory, optical Memory, high density embedded nonvolatile Memory, resistive random access Memory (ReRAM), magneto-resistive random access Memory (Magnetoresistive Random Access Memory, MRAM), ferroelectric Memory (Ferroelectric Random Access Memory, FRAM), phase change Memory (PHASE CHANGE Memory, PCM), graphene Memory, and the like. Volatile memory can include random access memory (Random Access Memory, RAM) or external cache memory, and the like. By way of illustration, and not limitation, RAM can be in various forms such as static random access memory (Static Random Access Memory, SRAM) or dynamic random access memory (Dynamic Random Access Memory, DRAM), etc. The databases referred to in the embodiments provided herein may include at least one of a relational database and a non-relational database. The non-relational database may include, but is not limited to, a blockchain-based distributed database, and the like. The processor referred to in the embodiments provided in the present application may be a general-purpose processor, a central processing unit, a graphics processor, a digital signal processor, a programmable logic unit, a data processing logic unit based on quantum computing, or the like, but is not limited thereto.

The technical features of the above embodiments may be arbitrarily combined, and all possible combinations of the technical features in the above embodiments are not described for brevity of description, however, as long as there is no contradiction between the combinations of the technical features, they should be considered as the scope of the description.

The foregoing examples illustrate only a few embodiments of the application and are described in detail herein without thereby limiting the scope of the application. It should be noted that it will be apparent to those skilled in the art that several variations and modifications can be made without departing from the spirit of the application, which are all within the scope of the application. Accordingly, the scope of the application should be assessed as that of the appended claims.

Claims

1. A method of failure point analysis, the method comprising:

2. The method of claim 1, wherein determining a failure type code for each data point comprises:

3. The method according to claim 2, wherein determining the failure type code of the current data point based on the failure type code of the neighboring data point of the current data point and/or the failure type code of the neighboring data point having a connection relationship, or based on the current maximum failure type code, comprises:

4. The method of claim 2, wherein traversing the data points of the test result row by row, determining a failure type code for each data point comprises:

5. The method of claim 4, wherein traversing the data points in the test result row by row further comprises:

6. The method of claim 4, wherein traversing the data points of the test result row by row, determining the failure type code for each data point further comprises:

7. The method of claim 6, wherein traversing all data points of the first row in turn, determining a failure type code for each data point in the first row comprises:

8. The method of claim 6, wherein traversing all data points in a next row, determining a failure type code for each data point in the next row comprises:

9. The method of claim 8, wherein the adjacent data point refers to a previous digit of the current data point and a data point in a previous row corresponding to the current data point, a previous digit of the current data point, and a previous digit of the current data point.

10. The method of claim 1, wherein the traversing each data point row by row again, updating the failure type code for each data point according to the relationship array, comprises:

11. A point of failure encoding apparatus, the apparatus comprising:

12. A computer device comprising a memory and a processor, the memory storing a computer program, characterized in that the processor implements the steps of the method of any one of claims 1 to 10 when the computer program is executed.

13. A computer readable storage medium, on which a computer program is stored, characterized in that the computer program, when being executed by a processor, implements the steps of the method of any one of claims 1 to 10.

14. A computer program product comprising a computer program, characterized in that the computer program, when executed by a processor, implements the steps of the method of any one of claims 1 to 10.