Method for dynamically processing large-scale STDF data based on index table and computing device

Abstract

The invention discloses a method for dynamically processing large-scale STDF data based on an index table and computing equipment, and the method comprises the following steps: firstly traversing a large-scale STDF file, constructing a general index table according to a data type, a data position and a data length, and then constructing a service index table according to a test item and a test result; according to user requirements, the position of required data in the STDF file is positioned by querying the general index table and the service index table, and the required data is dynamically read and processed; and outputting a processed data result. By constructing the general index table and the service index table respectively, rapid positioning and data extraction of large-scale STDF files can be achieved, and the tedious process of line-by-line scanning and analysis in a traditional method is avoided. Besides, due to the fact that the data are dynamically processed, the data are only read and processed when needed, the problem of resource consumption caused by one-time loading of the whole file in a traditional method can be avoided, and the data processing efficiency is greatly improved.

Description

Technical Field

[0001] The present invention relates to the field of storage of STDF semiconductor industry chip test data, and in particular to a method and computing device for dynamically processing large-scale STDF data based on an index table. Background Art

[0002] During the semiconductor testing process, test data is usually stored in the STDF format. The STDF specification provides a common format to save test data, so that test results provided by different manufacturers can be processed uniformly. However, with the continuous development of semiconductor testing technology, the size of STDF files continues to increase, and higher requirements are placed on data processing speed and processing capabilities. The traditional STDF processing method uses the method of fully parsing the entire STDF file to process STDF, which has the problems of low efficiency and high resource consumption. Especially when the STDF file is very large, it may not be parsed, and the software may even crash. Summary of the invention

[0003] The purpose of the present invention is to provide a method and computing device for dynamically processing large-scale STDF data based on an index table, so as to realize rapid positioning and data extraction of large-scale STDF, improve data processing efficiency and reduce resource consumption.

[0004] In order to solve the above technical problems, the present invention provides a method for dynamically processing large-scale STDF data based on an index table, the steps of the method comprising:

[0005] First, the large-scale STDF files are traversed, and a general index table is constructed according to the data type, data location, and data length. Then, a business index table is constructed according to the test items and test results.

[0006] According to user needs, locate the location of the required data in the STDF file by querying the general index table and the business index table, and dynamically read and process the required data;

[0007] Output the processed data results.

[0008] Furthermore, the step of constructing the general index table includes: initializing an STDF record type index table for storing data type identification information, wherein the index item of each record type in the STDF record type index table includes a data type identification and a corresponding data type code.

[0009] Furthermore, the step of constructing the general index table also includes:

[0010] Initialize the STDF record index table used to store data item index information;

[0011] Traverse the STDF file, extract the data length, data group and data type for each data item according to the REC_LEN, REC_TYP and REC_SUB fields, generate the corresponding index items and fill them into the STDF record index table;

[0012] A record index item is created for each data item in the STDF record index table, wherein the record index item includes a record identifier, a data type identifier, a starting position of the data item in the file, and a length of the data item.

[0013] Furthermore, the step of constructing the general index table also includes: associating the STDF record index table with the STDF record type index table through the data type identifier to achieve fast access to data items of different types.

[0014] Furthermore, the steps of constructing the business index table include:

[0015] Identify TSR data items in STDF files;

[0016] For the TSR data item, the test item number, test site number, and test header number are extracted, and a test summary index item is created in the STDF test summary index table. The test summary index item includes the test summary identifier, test item number, test site number, test header number, the starting position of the data item in the file, and the length of the data item.

[0017] Furthermore, the step of constructing the business index table further includes:

[0018] Identify MPR, PTR, and FTR data items in STDF files;

[0019] For MPR, PTR, and FTR data items, extract the test item number, test site number, and test head number;

[0020] Use the match(STDF_item) function to find a matching test summary identifier in the STDF test summary index table.

[0021] Furthermore, the step of constructing the business index table also includes:

[0022] The matched test summary identifier and other relevant field information of the MPR, PTR, and FTR data items are added to the corresponding MPR index table, PTR index table, and FTR index table to achieve quick access to the results of specific test items.

[0023] Furthermore, in the process of data processing, multi-threading or asynchronous processing techniques are adopted according to the system conditions.

[0024] In another aspect of the present invention, there is also provided a computing device, the computing device comprising: a processor, a memory, an input device, an output device and a software program;

[0025] The memory is used to store the software program, and the processor is used to call the software program stored in the memory to execute the above-mentioned method for dynamically processing large-scale STDF data based on the index table;

[0026] The input device is used to receive a user query request;

[0027] The output device is used to output the processing results.

[0028] Compared with the prior art, the present invention has at least the following beneficial effects:

[0029] The present invention provides a method and computing device for dynamically processing large-scale STDF data based on an index table, which is used to solve the problems of low efficiency and large resource consumption in the prior art. By constructing a general index table and a business index table respectively, rapid positioning and data extraction of large-scale STDF files are achieved, and the cumbersome process of line-by-line scanning and parsing in the traditional method is avoided, and when the user queries the data, the system can respond quickly, because only the requested data part needs to be loaded and processed, rather than the entire file, avoiding the need to process the entire file, improving the user experience, thereby greatly improving the data processing efficiency. In addition, due to the use of a dynamic processing method, data is read and processed only when needed, and the problem of resource consumption caused by loading the entire file at one time in the traditional method can be avoided. BRIEF DESCRIPTION OF THE DRAWINGS

[0030] Figure 1 It is a flow chart of a method for dynamically processing large-scale STDF data based on an index table in one embodiment of the present invention;

[0031] Figure 2 A typical STDF storage structure diagram in one embodiment of the present invention;

[0032] Figure 3 This is a Record storage structure diagram of STDF in one embodiment of the present invention;

[0033] Figure 4 A structural diagram of a general index table in one embodiment of the present invention;

[0034] Figure 5 A flowchart of constructing a general index table in one embodiment of the present invention;

[0035] Figure 6 A structural diagram of a service index table in an embodiment of the present invention;

[0036] Figure 7A flowchart of constructing a service index table in one embodiment of the present invention;

[0037] Figure 8 This is a detailed flow chart of data processing of a method for dynamically processing large-scale STDF data based on an index table in one embodiment of the present invention. DETAILED DESCRIPTION

[0038] A method and computing device for dynamically processing large-scale STDF data based on an index table of the present invention will be described in more detail below in conjunction with a schematic diagram, wherein preferred embodiments of the present invention are shown, and it should be understood that those skilled in the art can modify the present invention described herein, and still achieve the advantageous effects of the present invention. Therefore, the following description should be understood as being widely known to those skilled in the art, and not as a limitation of the present invention.

[0039] For the sake of clarity, not all features of the actual embodiments are described. In the following description, well-known functions and structures are not described in detail because they would clutter the invention with unnecessary detail. It should be recognized that in the development of any actual embodiment, a large number of implementation details must be made to achieve the developer's specific goals, such as changing from one embodiment to another according to the limitations of the relevant system or the relevant business. In addition, it should be recognized that such development work may be complex and time-consuming, but it is just a routine task for those skilled in the art.

[0040] The present invention is described in more detail in the following paragraphs by way of example with reference to the accompanying drawings. The advantages and features of the present invention will become more apparent from the following description. It should be noted that the accompanying drawings are in very simplified form and are not in exact proportions, and are only used to facilitate and clearly assist in illustrating the purpose of the embodiments of the present invention.

[0041] Embodiment 1:

[0042] like Figure 1 As shown, the present invention provides a method for dynamically processing large-scale STDF data based on an index table, comprising:

[0043] First, the large-scale STDF files are traversed, and a general index table is constructed according to the data type, data location, and data length. Then, a business index table is constructed according to the test items and test results.

[0044] According to user needs, locate the location of the required data in the STDF file by querying the general index table and the business index table, and dynamically read and process the required data;

[0045] Output the processed data results.

[0046] Specifically, before constructing the general index table, it is necessary to first understand the storage structure and data type of STDF. STDF is saved in the form of a binary byte stream, and contains up to 25 types of test data whose positions and lengths are not fixed in the entire STDF file (the test program may only write necessary data according to actual conditions, and not all STDF files will contain 25 types of test data).

[0047] like Figure 2 The figure shows a typical STDF storage structure. The data of a lot is recorded by MIR and MRR, including some SDR, PMR and other information at the beginning, and summary record information such as HBR, SBR, TSR, PCR at the end. The main body is a number of DUT test data blocks included by PIR and PRR.

[0048] In one embodiment, the STDF record storage structure is as follows: Figure 4 As shown in the figure, the first 6 fixed bytes of the STDF file are FAR information, and the other 24 types of test data all start with a 4-byte header, followed by the specific test data content. The following table 1 shows Figure 3 Type and description of each field in:

[0049] Table 1

[0050]

[0051] Therefore, if Figure 4 As shown, the steps of constructing the general index table include:

[0052] Initialize the STDF record type index table (also referred to as STDFRecord Type Index) for storing data type identification information, the index item of each record type (also referred to as Record Type) in the STDF record type index table includes a data type identification (also referred to as Data Type Id) and a corresponding data type encoding (also referred to as Data Type Code), wherein Data Type Id represents a data type identification, and Data Type Code represents a data type encoding. Its value definition is shown in Table 2 below, and this table should be initialized at startup in addition.

[0053] Table 2

[0054] DataTypeId DataTypeCode 1 FAR 2 ATR 3 MIR 4 MRR 5 PCR 6 HBR 7 SBR 8 PMR 9 PGR 10 PLR 11 RDR 12 SDR 13 WIR 14 WRR 15 WCR 16 PIR 17 PRR 18 TSR 19 PTR 20 MPR 21 FTR 22 BPS 23 EPS 24 GDR 25 DTR

[0055] Initialize an STDF record index table (also referred to as STDF RecordIndex) for storing index information of data items, and create a record (also referred to as Record) index item for each data item in the STDF record index table. The record index item includes a record identifier (also referred to as Record Id), a data type identifier (also referred to as Data Type Id), the starting position of the data item in the file (also referred to as Offset), and the length of the data item (also referred to as Size).

[0056] Traverse the STDF file, extract the data length, data group and data type for each data item according to the REC_LEN, REC_TYP and REC_SUB fields, generate the corresponding index items and fill them into the STDF Record Index index table.

[0057] like Figure 4 As shown, the STDF Record Index index table is associated with the STDFRecord Type Index index table through the Data Type Id, and the corresponding relationship is that n Records in the STDF Record Index index table correspond to 1 Record type in the STDF Record Type Index index table, thereby achieving fast access to data items of different types.

[0058] In one embodiment, the general index table construction process is as follows: Figure 5 As shown, when loading the STDF file, assuming that the nth data item has been traversed, let the data item be STDF_item(n), and its mapping in the STDF Record Index index be index_item(n). Then the index calculation formula is:

[0059] index_item(n).RecordId=index_item(n-1).RecordId+1;

[0060] index_item(n).DataTypeId = getDataTypeFromSTDFRecordTypeIndex(STDF_item(n)); / / Get the data type

[0061] index_item(n).Size=STDF_item(n).REC_LEN.Value+4;

[0062] Offset is an incremental data.

[0063] index_item(n).Offset=index_item(n-1).Offset+index_item(n-1).Size;

[0064] When n=0, index_item(0).RecordId=1; index_item(0).offset=0.

[0065] In the process of testing data, it is often necessary to view certain test items and their results separately, so it is particularly important to index the test items and test results. In order to shorten the query process and make the results more accurate, it is necessary to classify the data according to the data type, so as to construct Figure 6 The steps of constructing the business index table include:

[0066] Construct an STDF test summary index table (also called STDF Test Summary Index) to store test summary (also called Test Summary) index items. Each test summary index item includes a test summary identifier (also called Test Summary Id), a test item number (also called Test No), a test site number (also called Site), a test header number (also called Head Num), the starting position of the data item in the file, and the length of the data item.

[0067] Construct an MPR index table (also called MPR Index), a PTR index table (also called PTR Index), and an FTR index table (also called FTR Index) to store index items of MPR, PTR, and FTR test results, respectively. Each index item contains a unique identifier (also called ID), a test summary identifier (also called Test Summary Id), the length of the data item, and the starting position in the STDF file.

[0068] Traverse the TSR type data items in the STDF file, extract TestNo, Site, HeadNum for each TSR data item, and create a Test Summary index item in the STDF Test Summary Index, where the Test Summary index item includes Test Summary Id, Test No, Site, Head Num, Offset, and Size.

[0069] Traverse the data items of MPR, PTR and FTR types in the STDF file, extract the Test No, Site and Head Num for each MPR, PTR and FTR data item, and search for the matching Test SummaryId in the STDF Test Summary Index to generate the corresponding index items of MPR Index, PTR Index and FTR Index.

[0070] For each test result data item, extract the data length according to the REC_LEN field, calculate the Offset value, and fill it into the corresponding index item.

[0071] The business index table construction process is as follows Figure 7 As shown, the construction process of the business index table is an improvement on the general index table process. In order to make the query process shorter and the results more accurate, it is necessary to classify the data according to the data type and then construct the business index table. The business index calculation formula is as follows:

[0072] Formula 1:

[0073] STDFTestSummaryIndex_item(n).TestSummaryId=STDFTestSummaryIndex_item(n-1).TestSummaryId+1;

[0074] STDFTestSummaryIndex_item(n).TestNo=STDF_item(n).TestNo;

[0075] STDFTestSummaryIndex_item(n).Site=STDF_item(n).Site;

[0076] STDFTestSummaryIndex_item(n).HeadNum=STDF_item(n).HeadNum;

[0077] STDFTestSummaryIndex_item(n).Size=STDF_item(n).REC_LEN.Value+4;

[0078] Where offset is an incremental data.

[0079] STDFTestSummaryIndex_item(n).Offset = Commonindex_item(n - 1).Offset + Commonindex_item(n - 1).Size;

[0080] Where when n = 0, STDFTestSummaryIndex_item(0).TestSummaryId = 1;

[0081] Formula 2:

[0082] tmpIndex_item(n).TestNo = STDF_item(n).TestNo;

[0083] tmpIndex_item(n).Site = STDF_item(n).Site;

[0084] tmpIndex_item(n).HeadNum = STDF_item(n).HeadNum;

[0085] tmpIndex_item(n).Size = STDF_item(n).REC_LEN.Value + 4;

[0086] tmpIndex_item(n).Offset = Commonindex_item(n - 1).Offset + Commonindex_item(n - 1).Size;

[0087] Formula 3:

[0088] Index_item(n).Id = Index_item(n - 1).Id + 1;

[0089] Index_item(n).TestSummaryId = match(STDF_item).TestSummaryId;

[0090] Index_item(n).Size = STDF_item(n).REC_LEN.Value + 4;

[0091] Index_item(n).Offset = Commonindex_item(n - 1).Offset + Commonindex_item(n - 1).Size;

[0092] Where when n = 0, Index_item(0).Id = 1;

[0093] match(STDF_item(n-1)) function: ptr / ftr / mpr datasets all contain

[0094] testno / site / headnum, parse the current data item, extract these three elements, and search for matching index items in the STDF TestSummary Index table. If a match is found, return the Test Summary Id.

[0095] buildIndex(tmpIndex, TestSummaryIndex_item) function: Each data item in the tmp data set contains testno / site / headnum. The data set is matched with the Test Summary Index_item through the three items testno / site / headnum. The matched data items are added to the corresponding index table. For example, tmpPtrIndex is added to PtrIndex:

[0096] Index_item(n).Id=Index_item(n-1).Id+1;

[0097] Index_item(n).TestSummaryId=TestSummaryIndex_item.TestSummaryId;

[0098] Index_item(n).Size=tmpPtrIndex(n).Size;

[0099] Index_item(n).Offset=tmpPtrIndex(n).Offset.

[0100] In one embodiment, if Figure 7 As shown in the figure, when processing each data item, first determine the data type. When the data type is TSR, parse the data item into the STDF Test Summary Index index table according to formula 1; when the data type is PTR, Figure 7 According to the instructions in , the temporary tmp Ptr Index is constructed according to formula 2, or the PTRIndex is constructed according to formula 3, and finally the PTR data item is parsed into the Ptr Index index table. Similarly, the FTR data is parsed into the FTRIndex index table, and the MPR data is parsed into the MPR Index index table.

[0101] Therefore, by constructing a general index table and a business index table separately, it is possible to quickly locate and extract data from large-scale STDF files without scanning the entire file, avoiding the tedious process of line-by-line scanning and parsing in traditional methods, greatly improving the speed of data retrieval; in addition, by constructing a general index table and a business index table separately, when a user queries data, the system can respond quickly because only the requested data portion needs to be loaded and processed, rather than the entire file, avoiding the need to process the entire file, improving the user experience, and thus greatly improving data processing efficiency.

[0102] In one embodiment, if Figure 8 In the detailed data processing flow chart shown in the figure, the user obtains the required index items through the index table, and then allocates processing threads according to the number of indexes (assuming that n threads are allocated). The n threads quickly locate the location of the required data in the STDF file by querying the index (offset, size) in the index table, and dynamically read and process the data. In the data processing process, multi-threading, asynchronous processing and other technical means can be used to improve the data processing speed. The use of multi-threading technology allows multiple data streams to be processed simultaneously, thereby accelerating the entire data processing process. On a multi-core processor, CPU resources can be fully utilized to achieve true parallel processing. The use of asynchronous processing technology can avoid the program being idle while waiting for IO operations (such as reading data files) to complete, allowing the CPU to handle other tasks, thereby improving the data processing speed.

[0103] In addition, the present invention supports dynamic adjustment of parsing cycles and parsing points according to user needs, and can adapt to data processing requirements in different scenarios.

[0104] Specifically, when you need to find all the data under a certain Recordtype, first search the index table to find the location and size of the data item, and then parse the data item specifically. The query instruction is:

[0105] searchRecordsByTypes(Recordtype);

[0106] When you need to find the paging data under a certain Recordtype, the query instruction is: searchRecordsByTypes(Recordtype,pageindex,pagesize);

[0107] When you need to query all test items, the query formula is: searchTestItems();

[0108] When you need to search for test items by page, the query command is:

[0109] searchTestItems(pageindex,pagesize);

[0110] When you need to find the test result of a certain test item, the query command is:

[0111] searchTestResultsByTestNo(testno);

[0112] When you need to find all test results of a certain test type, the query instruction is: searchTestResultsByTestType(testtype).

[0113] Furthermore, the processed data is output in a user-specified format (such as CSV) so that the data can be read and processed by a variety of applications and tools, which can improve the compatibility and flexibility of the data. At the same time, the processed data can generate various visual charts according to user needs, that is, users can easily import data into Excel, databases, data analysis software or customized applications for further data processing and analysis, so that users can better understand and analyze test data.

[0114] In addition, in another aspect of the present invention, there is provided a computing device, comprising: a processor, a memory, an input device, an output device and a software program;

[0115] The memory is used to store the software program, and the processor is used to call the software program stored in the memory to execute the method for dynamically processing large-scale STDF data based on an index table as described above;

[0116] The input device is used to receive a user query request;

[0117] The output device is used to output the processing results.

[0118] Embodiment 2:

[0119] Taking the Result tool in ATE Studio as an example, a method for dynamically processing large-scale STDF data based on index tables is explained.

[0120] First, load a large-scale STDF file for scanning, extract key information and build an index. The index table uses key information as index items, specifically building a general index table and a business index table. Building a general index table and a business index table can greatly save storage resources.

[0121] Dynamically process data and display results according to business needs. Take two typical data display requirements as examples:

[0122] Table 3 below shows the result information of checking dut in STDF, which comes from PRR type data in STDF. This data can be obtained through the searchRecordsByTypes(Recordtype) method. Table 4 below shows the type and description of each field in Table 3.

[0123] Table 3

[0124]

[0125] Table 4

[0126] Fields type describe PartId int DUT Number X int X coordinate of the DUT Y int Y coordinate of the DUT Wafer string Chip number P / F string Success / Failure SW Bin string Soft Bin name HW Bin string Hard Bin Name Time long Test completion time (ms)

[0127] Table 5 below shows the statistics of the STDF test items, which come from the TSR data in STDF. The data can be obtained through the searchRecordsByTypes(Recordtype) method implemented in the solution. Table 6 below shows the type and description of each field in Table 5.

[0128] Table 5

[0129]

[0130] Table 6

[0131]

[0132] Table 7 shows all test result information of a test item by selecting a test item in Table 5. The data can be obtained by the searchTestResultsByTestNo(testno) method. Table 8 below shows the type and description of each field in Table 7.

[0133] Table 7

[0134]

[0135] Table 8

[0136] Fields type describe TestText string Test Description TestNo string Test No. Pattern string When the test type is FT test, the Pattern is displayed. Wafer string Chip number Site string Site Number Pin string Pin Name PartId int Dut Id Value decimal Dut measurement Unit string unit P / F string Success / Failure Time long Testing time

[0137] In summary, the present invention provides a method and computing device for dynamically processing large-scale STDF data based on an index table, which is used to solve the problems of low efficiency and large resource consumption in the prior art. By constructing a general index table and a business index table respectively, it is possible to achieve rapid positioning and data extraction of large-scale STDF files, avoiding the cumbersome process of line-by-line scanning and parsing in traditional methods; and by constructing a general index table and a business index table respectively, when a user queries data, the system can respond quickly, because only the requested data part needs to be loaded and processed, rather than the entire file, avoiding the need to process the entire file, improving the user experience, and thus greatly improving data processing efficiency. In addition, due to the use of a dynamic processing method, data is read and processed only when needed, which can avoid the problem of resource consumption caused by loading the entire file at one time in the traditional method.

[0138] The above is only a preferred embodiment of the present invention and does not limit the present invention in any way. Any technician in the relevant technical field, without departing from the scope of the technical solution of the present invention, makes any form of equivalent replacement or modification to the technical solution and technical content disclosed in the present invention, which does not depart from the content of the technical solution of the present invention and still falls within the protection scope of the present invention.

Claims

1. A method for dynamically processing large-scale STDF data based on an index table, characterized in that: The steps of the method include: First, the large-scale STDF files are traversed, and a general index table is constructed according to the data type, data location, and data length. Then, a business index table is constructed according to the test items and test results. According to user needs, locate the location of the required data in the STDF file by querying the general index table and the business index table, and dynamically read and process the required data; Output the processed data results.

2. The method for dynamically processing large-scale STDF data according to claim 1, characterized in that: The step of constructing the general index table includes: initializing an STDF record type index table for storing data type identification information, wherein the index item of each record type in the STDF record type index table includes a data type identification and a corresponding data type code.

3. The method for dynamically processing large-scale STDF data according to claim 2, characterized in that, The step of constructing the general index table also includes: Initialize the STDF record index table used to store data item index information; Traverse the STDF file, extract the data length, data group and data type for each data item according to the REC_LEN, REC_TYP and REC_SUB fields, generate the corresponding index items and fill them into the STDF record index table; A record index item is created for each data item in the STDF record index table, wherein the record index item includes a record identifier, a data type identifier, a starting position of the data item in the file, and a length of the data item.

4. The method for dynamically processing large-scale STDF data according to claim 3, characterized in that: The step of constructing the general index table also includes: associating the STDF record index table with the STDF record type index table through the data type identifier to achieve fast access to data items of different types.

5. The method for dynamically processing large-scale STDF data according to claim 1, characterized in that: The steps to construct a business index table include: Identify TSR data items in STDF files; For the TSR data item, the test item number, test site number, and test header number are extracted, and a test summary index item is created in the STDF test summary index table. The test summary index item includes the test summary identifier, test item number, test site number, test header number, the starting position of the data item in the file, and the length of the data item.

6. The method for dynamically processing large-scale STDF data according to claim 5, characterized in that: The steps of constructing the business index table further include: Identify MPR, PTR, and FTR data items in STDF files; For MPR, PTR, and FTR data items, extract the test item number, test site number, and test head number; Use the match(STDF_item) function to find a matching test summary identifier in the STDF test summary index table.

7. The method for dynamically processing large-scale STDF data according to claim 6, characterized in that: The steps of constructing the business index table also include: The matched test summary identifier and other relevant field information of the MPR, PTR, and FTR data items are added to the corresponding MPR index table, PTR index table, and FTR index table to achieve quick access to the results of specific test items.

8. The method for dynamically processing large-scale STDF data as claimed in claim 1, characterized in that: During the data processing process, multi-threading or asynchronous processing techniques are used according to the system conditions.

9. A computing device, characterized in that include: processors, memory, input devices, output devices, and software programs; The memory is used to store the software program, and the processor is used to call the software program stored in the memory to execute the method according to any one of claims 1 to 8; The input device is used to receive a user query request; The output device is used to output the processing result.

Images