STDF file analysis method and device and storage medium

Abstract

The invention provides an STDF file analysis method and device and a storage medium. The method comprises the following steps of: segmenting an STDF data stream, carrying out lamination data division on each data segment obtained by segmentation based on PIR and PRR data types, dividing a continuous data stream into small blocks of data of a plurality of logic levels, analyzing the small blocks of data with a small running memory, and carrying out parallel analysis on the lamination data and the plurality of small blocks of data based on computer multi-core operation, the analysis efficiency is improved; moreover, when the press fit data of one data packet is analyzed, the analysis result is transferred to the hardware storage device, so that the running memory can be released, and the conditions of lagging and dead halt are avoided; besides, analysis results including the test stations, the test items and the test results thereof are stored by adopting a multi-thread nested dictionary, equivalently, a mapping relation between each chip and the test items and the test results thereof is established, and the test results of each test item of a single chip can be accurately retrieved.

Description

Technical Field

[0001] This application relates to the field of semiconductor testing technology, specifically to a method, device, and storage medium for parsing STDF (Standard Test Data Format) files. Background Technology

[0002] Chips, including SOCs (system-on-chip), require testing during production. The test data generated during this process is typically saved as STDF files, which are binary data. Therefore, these binary STDF files need to be converted into directly readable data—a process known in the art as STDF file parsing. Currently, due to the increasing size and functionality of chips, the number of test items and test data has increased (e.g., typically exceeding 1GB to 10GB). This places high demands on the computer's RAM when parsing STDF files, frequently leading to lag and crashes. To avoid this problem and to quickly parse STDF files, existing technologies omit the precise parsing of individual chip test results. However, this results in the lack of ability to pinpoint the test results of individual chips, hindering testers from analyzing failed individual chips. In addition, STDF files are streaming data. Directly parsing this streaming data makes it impossible to locate which chip the current data corresponds to, making it difficult to locate the test content of a single chip. Ultimately, the test results of individual chips cannot be correlated with each other, which is not conducive to the analysis of failed individual chips by testers. Summary of the Invention

[0003] In view of this, this application provides a method, device, and storage medium for parsing STDF files, which can at least improve the problems of large memory usage for parsing STDF files and difficulty in tracing the test results of a single chip (e.g., the result of a certain test item).

[0004] This application provides a method for parsing STDF files, including: S1. Create an STDF class library, which defines the data types involved in the test, the test items contained in the data types, their test stations, and the character types corresponding to the test results; S2. Read the STDF data stream and segment the STDF data stream to obtain multiple data segments, each data segment corresponding to a complete data of a data type; S3. Identify PIR data type and PRR data type from each data segment, and record the first mark corresponding to the PIR data type and the second mark corresponding to the PRR data type, wherein the first mark and its next nearest second mark constitute a compressed data; S4. When the first mark accumulates to a preset value, the accumulated data is packaged into a data packet, and multiple compressed data are divided from the data packet based on the first mark and the second mark; S5. Parse each compression data in parallel using the STDF class library; S6. From the parsing results of each pressing data, identify the test station and test item and their test results corresponding to each pressing data, and construct a multi-threaded nested dictionary accordingly. S7. Transfer the multi-threaded nested dictionary from the running memory to the hardware storage device, and clear the cached data generated during the parsing process from the running memory; Repeat steps S2 through S7 until the parsing of the STDF file is complete.

[0005] Optionally, S5 includes: The compressed data is divided into multiple sub-packages according to the number of data segments; The STDF class library is used to parse each sub-package in parallel. Based on the parsing results, a multi-threaded dictionary is constructed with the number of times the compression data is applied as an index, which serves as the parsing result for each compression data.

[0006] Optionally, S5 further includes: The data contained in the multi-threaded dictionary is cleaned, and only the test station, test item and test result corresponding to each pressing data are retained as the parsing result of each pressing data.

[0007] Optionally, segmenting the STDF data stream to obtain multiple data segments includes: The format of each data type is determined, wherein the first byte and the second byte of any data type together represent the length n of the data type, and the n consecutive bytes after the second byte together with the first byte and the second byte form the complete data of a data type; The STDF data stream is segmented based on the data type format to obtain multiple data segments.

[0008] Optionally, the step of dividing the compressed data into multiple sub-packages according to the number of data segments includes: The format of each data type is determined, wherein the first byte and the second byte of any data type together represent the length n of the data type, and the n consecutive bytes after the second byte together with the first byte and the second byte form the complete data of a data type; The compressed data is divided into multiple data segments based on the data type format, with each data segment serving as a sub-package.

[0009] Optionally, S7 includes: The multi-threaded nested dictionary is converted into a data grid table, and the data grid table is transferred from the running memory to the hardware storage device in a compressed columnar storage manner.

[0010] Optionally, between S3 and S5, the method further includes: When multiple data segments have been read, if the cumulative value of the first marker is less than a preset value, then multiple compressed data are divided from the cumulative data based on the first marker and the second marker.

[0011] Optionally, when the first marker accumulates to less than a preset value, after step S7, the method further includes: transferring the data grid table from the running memory to a hardware storage device in CSV format.

[0012] Optionally, after S7, the following may also be included: The compressed columnar storage data obtained according to the compressed columnar storage method will be merged.

[0013] This application provides a parsing device, including a processor and a memory, wherein the memory stores a parsing program, and when the parsing program is executed by the processor, it implements the steps of any of the above-described STDF file parsing methods.

[0014] This application provides a storage medium storing a computer program, which, when executed by a processor, implements the steps of any of the above-described STDF file parsing methods.

[0015] As described above, this application segments the STDF data stream and then divides each segmented data segment into compressed data based on PIR and PRR data types. This accurately divides the continuous data stream into small blocks of data at multiple logical levels. The memory required for parsing these small blocks is relatively small. By leveraging multi-core computing, the compressed data and multiple small blocks are parsed in parallel, improving parsing efficiency. Furthermore, after parsing the compressed data of each data packet, the parsing result is transferred to a hardware storage device, releasing the occupied memory to facilitate the parsing of subsequent data packets and preventing lag or crashes. In addition, the parsing results, including test stations, test items, and their test results, are stored using a multi-threaded nested dictionary. This establishes a mapping relationship between each chip and the test items and their test results, allowing for precise retrieval of the test results for each test item of a single chip, which is beneficial for testers to analyze failed individual chips. Attached Figure Description

[0016] Figure 1 This is a flowchart illustrating a method for parsing STDF files provided in an embodiment of this application; Figure 2 This is a flowchart illustrating another method for parsing STDF files provided in an embodiment of this application; Figure 3 This is a schematic diagram of the structure of a parsing device provided in an embodiment of this application. Detailed Implementation

[0017] To address the aforementioned problems in the prior art, this application provides a method, apparatus, and storage medium for parsing STDF files. These protection subjects are based on the same concept, and their problem-solving principles are essentially the same or similar. The implementation methods of each protection subject can be referred to mutually, and repeated details will not be elaborated.

[0018] In this application's solution, the STDF data stream is segmented, and then each segmented data segment is further divided into compressed data based on PIR and PRR data types. This divides the continuous data stream into small blocks of data at multiple logical levels. The computer uses multi-core parallel parsing to reduce memory requirements and improve parsing efficiency. Furthermore, after parsing the compressed data of each data packet, the parsing result is transferred to hardware storage, releasing memory and further reducing memory requirements. In addition, the parsing results, including test stations, test items, and their test results, are stored using a multi-threaded nested dictionary. This establishes a mapping relationship between each chip and the test items and their test results, allowing for precise retrieval of the test results for each test item of a single chip, which is beneficial for testers to analyze failed single chips.

[0019] To make the objectives, technical solutions, and advantages of this application clearer, the technical solutions of this application will be clearly described below in conjunction with specific embodiments and corresponding drawings. Obviously, the embodiments described below are only a part of the embodiments of this application, and not all of them. Unless otherwise specified, the following embodiments and their technical features can be combined with each other, and also belong to the technical solutions of this application.

[0020] Figure 1 This is a flowchart illustrating an STDF file parsing method provided in an embodiment of this application. The STDF file parsing method can also be referred to as a "method" or "parsing method," and the executing entity for each step can be a suitable STDF file parsing device, a computer performing the parsing, or a storage medium, processor, controller, etc., with STDF parsing functionality.

[0021] Combined Figure 1 and Figure 2 As shown, the method includes at least the following steps S1 to S7.

[0022] S1. Create an STDF class library, which defines the data types involved in the test, the test items contained in the data types, their test positions, and the character types corresponding to the test results.

[0023] The core function of the STDF library is to provide the correspondence between binary data and directly readable data in STDF files. Computers can then parse STDF files based on this library. In one example, this application uses CSharp to compile and create the STDF library. This STDF library defines data types involved in testing, including but not limited to PIR (PartInformation Record), PRR (Part Result Record), FTR (Functional Test Record), PTR (Parametric Test Record), and MPR (Multi-Purpose Register). Test items, their corresponding test stations, and test results can be considered as subtype dictionaries defined by the STDF library for each data type. These subtype dictionaries contain the characters corresponding to the test items, test stations, and test results, and also define the corresponding character types. For example, in the FTR data type, the character type corresponding to the test station (SITE_NUMBER) of a certain test item is a byte integer.

[0024] This application uses CSharp to compile and create an STDF class library. During the parsing of STDF files, a data dictionary is built, and the STDF file is subsequently divided to avoid repeated data reading, thereby reducing the computer's memory usage and effectively improving file processing efficiency.

[0025] S2. Read the STDF data stream and segment the STDF data stream to obtain multiple data segments, each data segment corresponding to a complete data of a data type.

[0026] An STDF file is represented as a binary data stream, referred to as an STDF data stream. This application can read the entire STDF data stream at once. After obtaining the STDF data stream, it needs to be segmented to clarify the data structure. In one example, the segmentation is performed as follows: First, the format of each data type is determined, where the first and second bytes of any data type together represent the length n of that data type, and the next n bytes after the second byte, together with the first and second bytes, form the complete data of a data type; then, the STDF data stream is segmented based on the data type format to obtain multiple data segments.

[0027] For any of the data types PIR, PRR, FTR, PTR, and MPR, the first byte (byte0) and the second byte (byte1) together represent the data length n of that data type. The next n bytes constitute a data segment {byte1 + ... + byten}, which is called C data. C data can be considered as valid data of that data type. Based on this data structure, each segment is cut and extracted to obtain a complete unit of {data length information n + C data}, which can then be used as each data segment. Furthermore, the read position of each data segment is recorded, and the read position of each data segment and the C data are cached in the source data list to facilitate the subsequent location of the parsing result corresponding to each compressed data.

[0028] S3. Identify the PIR data type and PRR data type from each data segment, and record the first mark corresponding to the PIR data type and the second mark corresponding to the PRR data type, wherein the first mark and its next nearest second mark constitute a compressed data.

[0029] For any given data segment, the first and second bytes of the C data jointly identify the data type. Based on this, PIR and PRR data types can be identified from each data segment. Optionally, the corresponding position information is recorded to generate a list of first marker A and second marker B. Then, the lists of first marker A and second marker B are sorted according to the order of reading positions. In the sorted list, first marker A and second marker B appear alternately. Any first marker A and its nearest subsequent second marker B represent a complete touch-down (TD) data, also known as touch-down test data. The touch-down data refers to a data packet generated during the testing process where the test arm simultaneously grasps multiple chips and places them in a designated test fixture, connecting the chip pins (also known as chip leads) to the test machine channel for multi-chip synchronous testing. The test results contained in the touch-down data are still presented as binary data.

[0030] The segmented data processing architecture based on PIR and PRR precisely divides the continuous data stream into multiple logical layers, resulting in a more explicit data structure for subsequent storage, retrieval, and analysis.

[0031] S4. When the first marker accumulates to a preset value, the accumulated data is packaged into a data packet, and multiple compressed data are divided from the data packet based on the first and second markers.

[0032] In one example, when the cumulative number of the first tag A is a preset value H, the data read up to the current time is packaged into a data packet A0. Then, the data in the data packet A0 is organized and a clear data structure is defined. That is, based on the fact that the data between the first tag A and the second tag B is a compressed data, the list of the first tag A and the second tag B is read one by one to divide each compressed data. Then, the data in the data packet A0 is sorted according to the order of appearance of the compressed data.

[0033] In another example, this application also considers the case where the cumulative number of the first marker A does not reach a preset value H. Therefore, the method further includes: when multiple data segments have been read and the cumulative number of the first marker A is less than the preset value H, then multiple compressed data are divided from the cumulative data based on the first marker A and the second marker B, and these compressed data are sorted according to their order of appearance. Then, step S5 is performed to parse each compressed data.

[0034] S5. Parse each compression data in parallel using the STDF class library.

[0035] The computer utilizes its internal multi-core processor for parallel parsing, converting binary data into a specified character type. This parsing process transforms the binary data contained in each compressed data set into directly readable data. The resulting directly readable data includes at least the test station, test item, and the corresponding test result for each test item.

[0036] S6. From the parsing results of each pressing data, identify the test station, test item and test result corresponding to each pressing data, and construct a multi-threaded nested dictionary accordingly.

[0037] In one example, the name of each pressing data is used as the outer dictionary, and each test station in each pressing data, the test item executed at that test station, and the test result corresponding to each test item are used as the inner dictionary, thereby establishing a multi-threaded nested dictionary. The specific method and principle for establishing the multi-threaded nested dictionary can be found in existing technologies in this field, and will not be described in detail here.

[0038] S7. Transfer the multi-threaded nested dictionary from the runtime memory to the hardware storage device, and clear the cached data generated during the parsing process from the runtime memory.

[0039] In one example, this application can convert the multi-threaded nested dictionary into a data grid table. In a practical scenario, compression tests are obtained sequentially based on the multi-threaded nested dictionary. The number of compression data entries is converted into separate data columns. The row position for data entry is located according to the test station, and the column position is the name of the test item. Each item is entered into the data grid table to obtain the final data grid table. Then, the data grid table is stored in a compressed columnar storage method in a file E with a specified address and corresponding name, and then transferred from RAM to hardware storage. Compared to the multi-threaded nested dictionary, the data in the data grid table is easier to read and transfer later.

[0040] Repeat steps S2 through S7 until the parsing of the STDF file is complete.

[0041] When the data volume is large, repeating step S7 above will generate multiple files E with different names. This application can merge these multiple files E, that is, merge the compressed columnar storage data obtained according to the described compressed columnar storage method, and then transfer the merged data from the running memory to the hardware storage device in CSV (Comma-Separated Values) format. This CSV format facilitates subsequent data analysis and visualization. Since the data merging performance of compressed columnar storage is stronger than that of CSV data merging, compressed columnar storage is used to merge the data first before converting it to CSV data.

[0042] When the amount of data is small, that is, when the first marker A is less than the preset value H, after S7, this application will not generate multiple files E with different names. The data grid table can be directly converted into CSV format and transferred from the running memory to the hardware storage device in CSV format.

[0043] As described above, this application segments the STDF data stream and then compresses each segment based on PIR and PRR data types, thereby accurately dividing the continuous data stream into small blocks of data at multiple logical levels. This results in less memory required for parsing these small blocks, and less overall memory usage when the computer performs parallel parsing using multiple cores. This parallel parsing fully utilizes the parallel computing capabilities of the multi-core processing modules in the computer (or personal computer), achieving efficient use of computing resources and improving the response speed of the entire parsing system. Furthermore, after parsing the compressed data of each data packet, the parsing result is transferred to a hardware storage device, releasing the occupied memory to facilitate the parsing of subsequent data packets and preventing lag or crashes. Additionally, the parsing results, including test stations, test items, and their test results, are stored using a multi-threaded nested dictionary, effectively establishing a mapping relationship between each chip and the test items and their results. This allows for precise retrieval of the test results for each test item of a single chip, facilitating accurate tracing and efficient troubleshooting of problematic chips by testers.

[0044] In short, this application enables rapid parsing of large STDF files and accurate retrieval of test data for a single chip even when the computer is offline.

[0045] Please continue to refer to this as well. Figure 1 and Figure 2 As shown, in the aforementioned S5, the data within data packet A0 also needs to be processed. Because the complexity of test items varies across different chips, there may be situations where a single compressed data set contains many test items. Even with a large data volume, this will still place a significant demand on runtime memory for parsing. Therefore, this portion of the data needs to be further divided according to the specified number of test items, and then parsed in parallel. In one example, the aforementioned S5 may further include: S51, dividing the compressed data into multiple sub-packets based on the number of data segments; S52, parsing each sub-packet in parallel using the STDF library; and S53, constructing a multi-threaded dictionary indexed by the number of times the compressed data is compressed, as the parsing result for each compressed data set.

[0046] The method for S51 to divide the data into multiple sub-packets is as follows: First, the format of each data type is determined, wherein the first and second bytes of any data type together represent the length n of the data type, and the n consecutive bytes after the second byte, together with the first and second bytes, form the complete data of a data type; then, based on the format of the data types, the compressed data is divided into multiple data segments, each data segment being a sub-packet. Specifically, the number of data types in the compressed data is determined according to the format of the data types, and then the compressed data is divided into the same number of sub-packets.

[0047] Following step S53, this application can further clean the data contained in the multi-threaded dictionary, retaining only the test station, test item, and test results corresponding to each pressing data, as the parsing results for each pressing data. In practical scenarios, the multi-threaded dictionary contains all configuration information for the test items, requiring the removal of irrelevant test information and the retention of only key parameter information from the tests, such as the test station, test item, and the test results corresponding to each test item; then, a nested multi-threaded dictionary is constructed through step S6.

[0048] This application embodiment also provides a storage medium storing a parsing program, which is essentially a computer program, and when executed by a processor, the parsing program implements the steps of the STDF file parsing method as in any example.

[0049] The storage medium includes, but is not limited to, any one of read-only memory (ROM), random access memory (RAM), magnetic disk, and optical disk.

[0050] Since the parsing program stored in the storage medium can execute the steps in the STDF file parsing method of any embodiment provided in this application, the beneficial effects that the STDF file parsing method of any of the foregoing embodiments can achieve can be realized, as detailed in the foregoing embodiments, which will not be repeated here.

[0051] This application also provides a parsing device or chip, including a memory and a processor. The memory stores a parsing program, which, when executed by the processor, implements the steps of the STDF file parsing method of any of the foregoing embodiments; and / or, the parsing device or chip is provided with a storage medium as shown in the above example, and the processor loads the storage medium to execute the steps of the STDF file parsing method, thereby achieving the beneficial effects that the STDF file parsing method of the corresponding embodiment can achieve.

[0052] Figure 3This is a schematic diagram of the structure of a parsing device provided in an embodiment of this application. For example... Figure 3 As shown, the parsing device 30, also known as the STDF file parsing device 30, includes: Module 31 is created to create an STDF class library, which defines the data types involved in the test, the test items contained in the data types, their test stations, and the character types corresponding to the test results. The reading module 32 is used to read the STDF data stream and segment the STDF data stream to obtain multiple data segments, each data segment corresponding to a complete data of a data type; The first identification module 33 is used to identify PIR data type and PRR data type from each data segment, and record the first mark corresponding to the PIR data type and the second mark corresponding to the PRR data type, wherein the first mark and its next nearest second mark constitute a compressed data; The partitioning module 34 is used to package the accumulated data into a data packet when the first mark reaches a preset value, and to partition multiple compressed data from the data packet based on the first mark and the second mark; Parsing module 35 is used to parse each compression data in parallel using the STDF class library; The second identification module 36 is used to identify the test station and test item and their test results corresponding to each pressing data from the parsing results of each pressing data, and construct a multi-threaded nested dictionary accordingly; and to transfer the multi-threaded nested dictionary from the running memory to the hardware storage device, and clear the cached data generated during the parsing process from the running memory.

[0053] Through the cooperation of the above modules, the parsing of the STDF file is completed.

[0054] It should be understood that the various modules of the parsing device 30 described above can be represented as physical devices or virtual modules (i.e., commonly referred to as logical modules) in actual scenarios. A single module can be implemented by a single physical device or by two or more physical devices working together. Similarly, the function performed by a single module can be implemented by a single physical device or by two or more physical devices working together. Furthermore, the functions corresponding to each module can be implemented by the corresponding steps of the STDF file parsing method of any of the aforementioned embodiments.

[0055] The above are only some embodiments of this application and do not limit the patent scope of this application. For those skilled in the art, any equivalent structural transformations made using the content of this specification and drawings are similarly included within the patent protection scope of this application.

[0056] The use of step designations such as S1 and S2 in this document is intended to more clearly and concisely describe the corresponding content and does not constitute a substantial restriction on the order. In specific implementation, those skilled in the art may execute S2 first and then S1, etc., but these should all be within the protection scope of this application.

[0057] Although this document uses terms such as "first," "second," etc., to describe various types of information, this information should not be limited to these terms. These terms are only used to distinguish information of the same type from one another. Furthermore, the singular forms "a," "an," and "the" are intended to also include the plural forms. The terms "or" and "and / or" are interpreted as inclusive, or meaning either one or any combination thereof. Exceptions to this definition only arise when combinations of elements, functions, steps, or operations are inherently mutually exclusive in some way.

Claims

1. A method of parsing an STDF file, characterized by, The method comprises: S1, creating an STDF library, which defines data types related to tests and test items and their test stations and character types corresponding to test results contained in the data types; S2, reading an STDF data stream and segmenting the STDF data stream to obtain a plurality of data segments, each data segment corresponding to complete data of one data type; S3, identifying PIR data types and PRR data types from each data segment and recording a first mark corresponding to the PIR data type and a second mark corresponding to the PRR data type, wherein the first mark and the next second mark constitute a compressed data; S4, when the first mark accumulates to a preset value, packing the accumulated data into a data packet, and dividing a plurality of compressed data from the data packet based on the first mark and the second mark; S5, using a parallel mode to analyze each compressed data through the STDF library; S6, identifying test stations, test items and their test results corresponding to each compressed data from the analysis results of each compressed data, and constructing a multi-thread nested dictionary accordingly; S7, transferring the multi-thread nested dictionary from the running memory to the hardware storage device, and clearing the cache data generated in the analysis process from the running memory; Repeat S2 to S7 until the analysis of the STDF file is completed.

2. The method of claim 1, wherein, The S5 comprises: cutting the compressed data into a plurality of sub-packets according to the number of data segments; using a parallel mode to analyze each sub-packet through the STDF library; constructing a multi-thread dictionary indexed by the number of compressed data as the analysis result of each compressed data based on the analysis result.

3. The method of claim 2, wherein, The S5 further comprises: cleaning the data contained in the multi-thread dictionary, and only retaining the test stations, test items and their test results corresponding to each compressed data as the analysis result of each compressed data.

4. The method of claim 2, wherein: the segmenting the STDF data stream to obtain a plurality of data segments comprises: determining the format of each data type, wherein the first byte and the second byte of any data type together represent the length n of the data type, and the consecutive n bytes after the second byte together with the first byte and the second byte form the complete data of one data type; segmenting the STDF data stream based on the format of the data type to obtain a plurality of data segments; the cutting the compressed data into a plurality of sub-packets according to the number of data segments comprises: determining the format of each data type, wherein the first byte and the second byte of any data type together represent the length n of the data type, and the consecutive n bytes after the second byte together with the first byte and the second byte form the complete data of one data type; cutting the compressed data into a plurality of data segments based on the format of the data type, each data segment serving as a sub-packet.

5. The method of claim 1, wherein, The S7 comprises: The multi-threaded nested dictionary is converted into a data grid table, and the data grid table is transferred from the running memory to the hardware storage device according to a compressed column storage mode.

6. The method of claim 1, wherein, Between S3 and S5, further comprising: When the first mark accumulation is less than the preset value after the multiple data segments are read, multiple compressed data are divided from the accumulated data based on the first mark and the second mark.

7. The method of claim 5, wherein, When the first mark accumulation is less than the preset value, after S7, the method further comprises: The data grid table is transferred from the running memory to the hardware storage device in a CSV format.

8. The method of claim 5, wherein, After S7, further comprising: The compressed column storage data obtained according to the compressed column storage mode is merged.

9. A resolution device, comprising: A processor and a memory are included, and the memory stores a parsing program, and when the parsing program is executed by the processor, the steps of the STDF file parsing method according to any one of claims 1 to 8 are implemented.

10. A storage medium, characterized by A computer program is stored, and when the computer program is executed by the processor, the steps of the STDF file parsing method according to any one of claims 1 to 8 are implemented.

Images