Two-level cache and dynamic column alignment method and system for multi-lane test data

Abstract

The application discloses a secondary cache and dynamic column alignment method and system for multi-channel test data, and particularly relates to the technical field of semiconductor test data management, which comprises S1, partition building storage, S2, index updating, S3, dynamic alignment, S4, precision calculation rate, S5, security packaging, S6, unified sequencing, S7, redundancy removal assembly, S8, batch storage, and S9, direct display rendering. The application adopts a local primary cache partition independent reading and writing architecture, and combines a remote secondary cache asynchronous batch writing mechanism, so that the network overhead is greatly reduced, and the real-time processing requirement of multi-channel test data is adapted, thereby solving the problems of column mispositioning and inaccurate statistical precision when a new channel is accessed.

Description

Technical Field

[0001] This invention relates to the field of semiconductor test data management technology, and in particular to a method and system for secondary caching and dynamic column alignment of multi-channel test data. Background Technology

[0002] In the semiconductor testing and manufacturing process, testing equipment uses multi-site parallel testing technology to test multiple chips simultaneously, with each site representing an independent testing channel. During testing, each site generates Touchdown data in real time, including the total number of tests, the number of passes, the number of failures, hard bins, soft bins, and yield indicators. This data needs to be aggregated and displayed on the CIM dashboard in real time for production line managers to monitor production quality. For example, a distributed real-time testing system test data collection method technology, as described in patent publication number CN103488565A, provides a method for clearing the secondary cache of the real-time simulation node to prepare for the next data write. The master node queries the primary cache, reads the data from the primary cache, writes it to the secondary cache, and then clears the primary cache. When the master node's secondary cache is nearly full, it writes the data in the secondary cache in binary file format to the master node's disk. After the test stops, the result file is read from the disk and stored in the database, with the result file divided into 10MB blocks and stored in the database according to the time tag order. However, the following problems still exist.

[0003] The three existing mainstream solutions all have significant shortcomings in semiconductor multi-channel parallel testing scenarios: direct writing to the database is prone to high-frequency IO blocking, front-end polling and aggregation results have high latency, single-layer Redis full calculation consumes a lot of remote computing power, network overhead surges under multi-channel concurrency, timed batch calculation is difficult to adapt to the real-time requirements of test data, and column misalignment and statistical inaccuracy are also prone to occur when new channels are connected. Summary of the Invention

[0004] To solve the above technical problems, the following technical solution is proposed: A method and system for secondary caching and dynamic column alignment of multi-channel test data, including the following specific steps: S1. Partitioned storage: Construct a local first-level cache and a global site identifier set. The local first-level cache is divided into independent statistical storage partitions. S2, Metrics Update: Update the channel test statistics metrics of each partition in the local first-level cache line by line, and update the global site identifier set synchronously. S3. Dynamic alignment: Identify the first appearance of the test channel identifier, trigger the automatic column backfill operation of all historical data rows, and complete the dynamic column alignment. S4, Precision Calculation: Calculates the test yield indicators of each channel and the overall test based on a high-precision numerical calculation model. S5. Secure encapsulation: Encapsulates dedicated data structures for integer count rows and text display rows to achieve thread-safe atomic count updates; S6. Unified sorting: Define unified sorting weight rules for data columns and standardize the sorting of output fields for all cached rows. S7. Redundancy removal and assembly: Batch integrate all data from the local first-level cache, reuse existing cached data to build classification and statistical results, and eliminate redundant storage. S8, Batch Write-in: Asynchronous batch writes the integrated aggregated data to the remote second-level cache all at once; S9, direct rendering: the front end reads standardized sorted data from the remote second-level cache and renders and displays it directly.

[0005] Preferably, the local first-level cache in S1 is implemented using a concurrent hash container, which divides the site yield statistics area, integer data row area, and text data row area. The global site identifier set is implemented using a concurrent hash set, which uniformly stores all online test channel identifiers. Each partition can be read and written independently without blocking each other.

[0006] Preferably, in S2, each ground contact test data is used to retrieve the site yield object with the channel identifier as the key, and the total number of tests, the number of qualified tests, and the number of failures are atomically accumulated, while the count indicators of the corresponding integer statistical rows of hard classification and soft classification are updated synchronously.

[0007] Preferably, in S3, when a new channel identifier is added to the global site set, it is determined to be a new channel. All historical integer rows in the local database are traversed to perform zero-padding operation if the key does not exist. Text rows are traversed to fill in the default display value according to the type. There is no need to temporarily fill in the field during the query stage.

[0008] Preferably, step S4 uses a high-precision decimal arithmetic class to perform yield calculation, sets a fixed decimal precision and a rounding mode, and uses the arithmetic mean of the yield of each channel as the overall yield of the whole machine to avoid the defect of loss of precision in floating-point arithmetic. Step S5 sets an integer row encapsulation class, with an internal ordered hash table to store channel values, and achieves concurrent lock-free counting through merging atomic operations; the text lines distinguish between two storage structures: yield text and category title text.

[0009] Preferably, S6 sets column sorting weights: title weight -1, total weight 0, and weights for each test channel are assigned in ascending order by number. When outputting, ordered key-value pairs are generated in ascending order of weights to ensure that the order of JSON fields is fixed and consistent.

[0010] Preferably, when S7 constructs hard-class and soft-class summary data, it directly traverses the existing data in the local first-level cache for real-time assembly, without opening a separate cache to store the classification statistics data, thereby reducing memory usage.

[0011] Preferably, after all the grounding test data in a single batch of S8 has been processed, only a single network serialization and write request is initiated to store the site summary data and the full-dimensional statistical data into two independent keys in the remote cache, thereby reducing network IO and serialization overhead.

[0012] A semiconductor multi-channel parallel test data secondary cache and dynamic column alignment system is used to execute a semiconductor multi-channel parallel test data secondary cache and dynamic column alignment method, including: Includes: local first-level cache module, dynamic column alignment module, thread-safe data encapsulation module, high-precision yield calculation module, data standardization and sorting module, data redundancy removal and construction module, and remote second-level cache asynchronous refresh module; The local first-level cache module is divided into site yield partition, integer data partition, text data partition, and global site identifier set. It is used to build a local memory concurrent cache storage architecture. Through multi-partition isolated storage, test statistics data, numerical data, and text display data are classified and read and written independently. The global site identifier set is used to collect all online test channel identifiers in real time. The local first-level cache module interacts bidirectionally with the dynamic column alignment module, the thread-safe data encapsulation module, and the data redundancy removal and construction module. The dynamic column alignment module is configured with a new channel registration unit and a historical row backfilling execution unit. The new channel registration unit is used to monitor the global site identifier set in real time, identify newly added unregistered test channels and complete the registration. The historical row backfilling execution unit is used to trigger the operation of zeroing all historical integer data rows and default value filling of text data rows in the local first-level cache. It completes the automatic alignment of multi-channel data columns in the cache preprocessing stage, replacing the inefficient method of temporarily filling fields at the front end. The thread-safe data encapsulation module includes an integer row encapsulation unit and a text row storage unit. The integer row encapsulation unit is used to encapsulate an ordered hash table data structure and realizes multi-threaded lock-free count updates through atomic merging operations. The text row storage unit is used to classify and store yield display text and category title text, and isolate numerical calculation and text display logic. The high-precision yield calculation module is used to load preset high-precision decimal operation rules, fixed decimal precision and rounding mode, and independently complete the calculation and solution of single-channel test yield and overall machine yield, abandoning the traditional ordinary floating-point operation mode and avoiding long-term data accumulation. The data standardization and sorting module is used to pre-store fixed data column weight sorting rules, classify the title field, total summary field, and data fields of each channel according to weight, sort all cached output fields uniformly according to the weight ascending order rule, generate ordered key-value pairs, and realize the standardization and unification of the order of all output JSON data fields; The data redundancy removal module is used to traverse the original data of each partition of the local first-level cache in real time, and assemble hard failure and soft failure classification and summary statistics online. It does not require a separate independent cache to store the summary data, and reuses existing cache resources to complete data aggregation. The remote secondary cache asynchronous refresh module establishes a data connection with the data redundancy removal and construction module. After all test data in a single batch has been processed and assembled, it performs a single unified serialization and asynchronous network write operation, storing the site summary data and full-dimensional detailed data into independent keys of the remote secondary cache, which greatly reduces the number of network I / O operations and serialization overhead.

[0013] The present invention has the following technical effects: 1. This invention adopts a local first-level cache partition independent read and write architecture, combined with a remote second-level cache asynchronous batch write mechanism, which completely avoids the high-frequency IO blocking problem, greatly reduces network overhead, and adapts to the real-time processing needs of multi-channel test data.

[0014] 2. This invention features a dynamic column auto-alignment mechanism. When a new channel is accessed, it can automatically adapt and fill all historical data columns. It achieves data column regularization from the cache preprocessing stage, completely avoiding column misalignment and field missing problems. The front end can directly render without secondary processing.

[0015] 3. The entire process of this invention adopts a thread-safe concurrent data structure and high-precision calculation logic, supports lock-free read and write in multi-threaded high-concurrency scenarios, eliminates counting deviation and precision accumulation loss, and reduces memory occupation through a non-redundant real-time assembly mechanism, and standardizes data output throughout the process.

[0016] 4. This invention addresses the pain points of multi-channel parallel testing scenarios in semiconductors, achieving a performance leap through a collaborative architecture of local level 1 cache and remote level 2 cache: Leveraging microsecond-level write capabilities and an asynchronous batch refresh mechanism, end-to-end latency is compressed from seconds to sub-seconds, significantly reducing network I / O overhead. Upon initial access to a new channel, all historical data rows are automatically backfilled, achieving dynamic column alignment from the cache layer, completely eliminating column misalignment and field order disorder issues. Rounding operations are used to avoid floating-point precision loss, ensuring that the dashboard yield is completely consistent with the actual value. Atomic operations enable safe concurrent writing by multiple threads, directly reusing existing caches to construct various statistical data, reducing memory usage. A unified sorting mechanism ensures standardized output with fixed field order, allowing direct rendering by the front-end without additional processing. Attached Figure Description

[0017] Figure 1 This is a schematic diagram of the process of the secondary caching and dynamic column alignment method for multi-channel test data in an embodiment of the present invention.

[0018] Figure 2This is a schematic diagram of the semiconductor multi-channel parallel test data secondary cache and dynamic column alignment system of the present invention. Detailed Implementation

[0019] References are attached. Figure 1 -Appendix Figure 2 As shown, the embodiments of the present invention disclose a method for secondary caching and dynamic column alignment of multi-channel test data, resulting in the following three sets of embodiments.

[0020] Example 1: 4-channel conventional steady-state test (no new channels, conventional batch test). This example is applicable to the normalized fixed 4-channel semiconductor chip test scenario on the production line, without any temporary addition of test channels. It is used to verify the cache stability, data accuracy, redundancy removal effect and IO optimization performance under normal operating conditions.

[0021] S1. Partitioned Storage (Local First-Level Cache Architecture): A local first-level cache is built using a ConcurrentHashMap container, strictly divided into three independent storage partitions: site yield statistics, integer data rows, and text data rows. Each partition allows independent read and write operations without blocking. A global site identifier concurrent hash set (ConcurrentHashSet) is initialized, pre-loaded with four fixed test channel identifiers: CH01, CH02, CH03, and CH04, with no null values ​​or duplicate identifiers. The site yield statistics partition stores core statistical data for each channel, including total test volume, pass volume, hard failure volume, and soft failure volume. The integer data rows partition stores pure numerical statistical results for backend precision calculations. The text data rows partition stores formatted text and category title text displayed on the front end, achieving isolation between calculation and display logic. All partitions are initialized with a memory threshold of 16MB, supporting 20 threads for concurrent read and write operations without blocking.

[0022] S2. Indicator Update (Row-by-Row Atomic Statistical Update): This batch involves testing 1000 chip sets. Each test data point uses the channel identifier as a unique key to retrieve the corresponding site's yield statistics object. Statistical indicators are accumulated through atomic operations to eliminate concurrent counting bias. Basic statistical data for each channel after testing: CH01: Total tests 1000, Pass 992, Failures 8 (3 hard failures, 5 soft failures); CH02: Total tests 1000, Pass 989, Failures 11 (4 hard failures, 7 soft failures); CH03: Total tests 1000, Pass 995, Failures 5 (2 hard failures, 3 soft failures); CH04: Total tests 1000, Pass 991, Failures 9 (5 hard failures, 4 soft failures). The global site identifier set is updated synchronously, confirming that all four channel identifiers are registered, with no additions or missing identifiers. The basic count data for the integer statistical rows and text display rows is also updated synchronously.

[0023] S3. Dynamic Alignment (Historical Data Column Backfill Alignment): This batch is for fixed channel testing. No new channel identifiers have been added to the global site identifier set, indicating no need for new channel registration. Therefore, zero-padding or default value padding is unnecessary. The local first-level cached historical data columns perfectly match the current test channel, with unified data column dimensions and complete fields. The original alignment is maintained, avoiding stuttering and misalignment issues caused by temporary field additions on the front end. Column alignment accuracy is 100%.

[0024] S4. Precision Rate Calculation (High-Precision Yield Calculation): This function abandons traditional double floating-point arithmetic and adopts the Java high-precision Decimal arithmetic class. It defaults to retaining 4 decimal places and uses HALF_UP rounding mode. Yield is calculated channel by channel, and then the overall yield of the entire machine is obtained. Specific calculation results: CH01 yield 99.20%, CH02 yield 98.90%, CH03 yield 99.50%, CH04 yield 99.10%; Overall yield = (99.20 + 98.90 + 99.50 + 99.10) ÷ 4 = 99.18%. There is no loss of precision accumulation throughout the process, and the error rate approaches 0.

[0025] S5. Secure Encapsulation (Thread-Safe Data Structure Encapsulation): This section calls the integer statistics row encapsulation class, which uses a built-in ordered hash table to store the numerical data from four channels. Through atomic accumulation operations, it enables concurrent lock-free count updates by 20 threads, preventing multi-threaded read / write conflicts and data overwriting issues. The text rows are categorized into two structures: title text and yield display text. The title text is fixed as "Channel Number, Total Tests, Passes, Failures, Yield," and the yield text format uniformly retains two decimal places. This completes the structured encapsulation of data, ensuring data standardization and thread safety.

[0026] S6. Unified sorting (standardized sorting of data column weights), strictly adhering to preset weight rules: title weight -1, total weight 0, channel number weight increasing from smallest to largest (CH01 weight 1, CH02 weight 2, CH03 weight 3, CH04 weight 4). All cached output fields are arranged in ascending order of weight, generating fixed ordered JSON key-value pairs, completely solving the problems of unordered JSON fields and front-end rendering errors in traditional solutions, and ensuring that the output data format is completely standardized.

[0027] S7. Redundancy Removal and Assembly (Redundant Data Aggregation): Traverses existing partition data in the local first-level cache, assembling hard classification, soft classification, and full summary statistics in real time online, without the need for a separate cache to store summary data. Directly reuses existing integer and text line cache resources, integrating failure classification data from various channels and overall test data. Compared to traditional solutions that store summary data separately, this significantly reduces memory redundancy and ensures no duplicate data storage in this batch.

[0028] S8, Batch Write (Asynchronous Batch Second-Level Cache Write): After all 1000 sets of test data in this batch have been processed and assembled, only one serialization operation and one network write request are performed. The data is divided into two independent keys and stored in the remote Redis second-level cache: Key1 stores the site's overall summary data, and Key2 stores the detailed data of all four channels. Traditional solutions require writing line by line, requiring 1000 IO requests per batch. This solution only requires one, significantly reducing IO overhead.

[0029] S9, direct rendering (high-efficiency front-end rendering): The front-end directly reads standardized, sorted, and fully aligned structured data from the remote second-level cache, without secondary processing or temporary field addition. Page rendering is completed in milliseconds, and the displayed data is neat, consistent, and without missing or incorrect data.

[0030] Example 2: 8-channel dynamic addition test case (adding 2 test channels, dynamic column alignment verification). This example is applicable to the scenario of dynamic expansion of test channels on the production line. Initially, there are 6 channels for testing. Two test channels, CH05 and CH06, are added in the middle of the batch. The core verification is the automatic alignment of dynamic columns and the compatibility and adaptation of new channel data in this solution.

[0031] S1. Partitioned storage: Initialize the local first-level cache with three independent partitions. The global site identifier set is pre-loaded into the initial channels: CH01, CH02, CH03, CH04, CH05, and CH06. The cache concurrent container supports a maximum of 16 channels of data storage. Read and write operations are isolated for each partition, with no blocking or conflicts. After initialization, the cache is in a test-ready state, with balanced memory allocation and no redundant usage.

[0032] S2. Indicator Update: In the first half of the batch, 1000 sets of tests were completed across 6 channels, and the statistical indicators for each channel were accumulated atomically as usual. In the middle of the test, two new test channels, CH07 and CH08, were added. The CH07 and CH08 identifiers were entered into the global site identifier set in real time, and the data statistics for the new channels were started simultaneously. After the entire batch of tests was completed, the data from the original 6 channels was fully accumulated, and the 2 new channels were counted from zero, with no data overwriting and no count omissions. The hardware and software failure classification indicators were updated synchronously to the corresponding integer data rows.

[0033] S3. Dynamic Alignment: When the system detects the addition of CH07 and CH08 identifiers to the global site collection, it determines that these are new, unregistered channels and automatically triggers a full historical data column backfilling operation. It iterates through all historical integer data rows in the local first-level cache, padding blank fields in CH07 and CH08 with zeros (initial values ​​for total test volume, qualified volume, and failed volume are set to 0); it iterates through text data rows, filling the new channel's text fields with the default display value "0.00%". This completes the automatic alignment of all 8 channels' columns across all dimensions during the cache preprocessing stage, eliminating the need for temporary field additions on the front end and completely resolving the issues of missing or misaligned data columns for new channels, achieving 100% column alignment accuracy.

[0034] S4. Precision Calculation: A high-precision Decimal calculation model is used, with unified precision rules to calculate the yield of 8 channels and the overall yield of the machine. The original 6 channels maintain the normal yield range, and the initial test data of the two newly added channels are fully included in the statistics, with no precision loss and no calculation deviation. The final yields of each channel are 99.12%, 98.86%, 99.35%, 99.01%, 98.79%, 99.42%, 99.00%, and 98.95%, respectively. The overall yield of the machine = the average yield of the 8 channels = 99.06%, with a data precision error of <0.01%.

[0035] S5. Secure encapsulation: Update the ordered hash table of the integer row encapsulation class, add CH07 and CH08 value storage nodes, and complete the concurrent count update of the new channel through atomic merging operations, ensuring conflict-free multi-threaded read and write operations. Text row synchronous expansion: Add two channels for title text and yield display text storage structures, maintaining complete isolation between numerical calculation and text display logic, and keeping the thread safety level unchanged.

[0036] S6. Unified sorting: Automatically adapts to 8-channel sorting according to weight rules. Title weight -1, summary weight 0, channel weights are assigned from 1 to 8 in ascending order of number. All data fields are automatically rearranged in ascending order of weight. The output JSON field order is fixed. New channel data is automatically embedded in the sorting sequence, with no sorting errors or field offset issues.

[0037] S7 performs deduplication and reassembles existing first-level cache data, assembling 8-channel full-dimensional summary data and software / hardware failure classification data in real time. There is no need to allocate separate cache space for new channels, there is no duplicate data storage, and memory usage only increases slightly with the amount of valid test data, with no redundancy or waste.

[0038] S8 batch write: After all 1000 sets of test data from 8 channels in the batch have been processed, aligned and assembled, a single asynchronous serialization and remote cache write is performed. The summary data and detailed data are stored in two independent cache keys respectively. Compared with the traditional sequential write mode, it completely avoids the overhead of frequent network I / O.

[0039] S9 features direct rendering, with the front end reading standardized and aligned data from the second-level cache. The 8-channel data columns are complete and neatly sorted, and newly added channel data is displayed normally without blanks, misalignments, or delays. The rendering efficiency is more than 60% higher than the traditional front end field filling mode.

[0040] Example 3: 16-channel high-concurrency extreme test scenario (high concurrency, large data volume, extreme performance verification). This example is applicable to high-end semiconductor 16-channel parallel high-concurrency test scenarios, with 20 threads simultaneously reading and writing, and a single batch of 1000 groups of large-scale tests. The core verification is the extreme performance of this solution in terms of high concurrency stability, low redundancy, high precision, and low IO overhead.

[0041] S1 features partitioned storage, initializing a high-concurrency-adaptive local first-level cache. It constructs three partitions based on a high-concurrency hash container, adapting to full-load data storage of 16 channels. The global site identifier set is entered at once for all channel identifiers from CH01 to CH16. The partition isolation strategy has been upgraded, with each partition supporting 20 threads for lock-free concurrent read and write operations. Read and write operations do not block or interfere with each other, cache initialization stability meets standards, and there is no risk of memory overflow.

[0042] S2, Metric Update: 20 threads concurrently process 16 channels and 1000 sets of test data. Using the channel identifier as the key, it atomically accumulates the total number of tests, pass rate, hard failure rate, and soft failure rate for each channel row by row, with no count overwriting, no data corruption, and no concurrency bias throughout the process. All channel identifiers are synchronized to the global site set in real time, ensuring 100% real-time data updates. Integer and text data row metrics are synchronously and iteratively updated.

[0043] S3. Dynamic alignment: This batch is a full-configuration fixed-channel test with no new channels added. There are no updates to the global site collection. The historical data columns are completely matched with the 16-channel test dimensions. There is no need to perform backfill value operations. The data columns are aligned throughout and the dimensions are complete. There are no data missing or field disorder issues in high-concurrency scenarios.

[0044] S4. Precision Calculation: Employs a high-precision decimal arithmetic model to shield against floating-point errors caused by high-concurrency accumulation, and standardizes 4-decimal-place calculations and 2-decimal-place display rules. The yield rate of a single 16-channel unit remains stable between 98.75% and 99.62%. After averaging, the overall yield rate is 99.15%, with no cumulative precision loss throughout the process and an error rate of <0.005%, far superior to traditional floating-point arithmetic solutions.

[0045] S5. Secure encapsulation: The integer row encapsulation class uses multi-atomic operation merging technology to achieve high-concurrency, lock-free count updates with 20 threads. An ordered hash table stably stores 16-channel numerical data with no data loss and no sorting disorder. Text rows are categorized and stored as 16-channel title text and yield display text. The computational logic and display logic are completely isolated, maximizing thread safety under high concurrency.

[0046] S6. Unified sorting, strictly adhering to weighted sorting rules, automatically adapting to the weight allocation of 16 channels. The title, summary, and data of each channel are arranged in ascending order according to their weights. When outputting batch data with high concurrency, the order of JSON fields is fixed and consistent throughout the process, with no random sorting or field drift issues, and the data standardization degree is 100%.

[0047] S7. Redundancy-free assembly: In high-concurrency scenarios, it directly traverses the original data in the local first-level cache to assemble full-dimensional summary and categorized statistical data in real time, without adding a separate cache to store the summary results, maximizing the reuse of cache resources. Compared with the traditional solution's dual redundancy mode of storing summary data and detailed data separately, this solution significantly reduces memory redundancy, and memory usage remains stable and controllable under high load.

[0048] S8, batch storage: After processing 1000 sets of test data across 16 channels with high concurrency, only one serialization and one network I / O write are performed. The summary data and detailed data are stored separately in a remote secondary cache with dual independent keys. Traditional high-concurrency solutions require tens of thousands of I / O requests per batch. This solution drastically reduces I / O and serialization overhead, significantly improving the efficiency of storing large batches of test data.

[0049] S9 features direct rendering, where the front end directly reads the complete data after standardization, alignment, and redundancy removal from the second-level cache. This ensures that there is no rendering lag, no missing data, and no column errors when handling large amounts of data with high concurrency, significantly improving the real-time performance and stability of the page display.

[0050] The following experimental data table is derived from the above three sets of specific embodiments: Note: Single channel yield = (number of qualified tests per channel ÷ total number of tests per channel) × 100%, rounded to two decimal places.

[0051] Overall yield rate = (sum of yield rates of all test channels ÷ total number of valid test channels) × 100%, rounded to two decimal places.

[0052] Data alignment accuracy = (Number of correctly aligned data columns ÷ Total number of data columns) × 100%; Cache redundancy rate = (memory usage of this solution ÷ memory usage of traditional solution) × 100%. The lower the value, the better the redundancy reduction effect.

[0053] Data accuracy error rate = |Standard true value - Measured statistical value| ÷ Standard true value × 100%.

[0054] IO overhead reduction rate = (Number of traditional IO operations - Number of IO operations in this solution) ÷ Number of traditional IO operations × 100%.

[0055] In summary, this solution precisely addresses the industry pain points of multi-channel parallel testing scenarios in the semiconductor industry. It constructs a collaborative architecture of independent read / write of local first-level cache partitions and asynchronous batch write of remote second-level cache. Relying on microsecond-level local write capabilities combined with a batch refresh mechanism, it compresses end-to-end processing latency from seconds to sub-seconds, significantly reducing high-frequency IO blocking and redundant network overhead. Equipped with a native dynamic column auto-alignment mechanism, it automatically completes the adaptation and filling of all historical data rows when a new channel is first connected, achieving column regularization from the cache layer and completely eliminating column misalignment, missing fields, and JSON order disorder issues.

[0056] The above are all preferred embodiments of the present invention and are not intended to limit the scope of protection of the present invention. Therefore, all equivalent changes made in accordance with the structure, shape and principle of the present invention should be covered within the scope of protection of the present invention.

Claims

1. A method and system for secondary caching and dynamic column alignment of multi-channel test data, characterized in that: The specific steps are as follows: S1. Partitioned storage: Construct a local first-level cache and a global site identifier set. The local first-level cache is divided into independent statistical storage partitions. S2, Metrics Update: Update the channel test statistics metrics of each partition in the local first-level cache line by line, and update the global site identifier set synchronously. S3. Dynamic alignment: Identify the first appearance of the test channel identifier, trigger the automatic column backfill operation of all historical data rows, and complete the dynamic column alignment. S4, Precision Calculation: Calculates the test yield indicators of each channel and the overall test based on a high-precision numerical calculation model. S5. Secure encapsulation: Encapsulates dedicated data structures for integer count rows and text display rows to achieve thread-safe atomic count updates; S6. Unified sorting: Define unified sorting weight rules for data columns and standardize the sorting of output fields for all cached rows. S7. Redundancy removal and assembly: Batch integrate all data from the local first-level cache, reuse existing cached data to build classification and statistical results, and eliminate redundant storage. S8, Batch Write-in: Asynchronous batch writes the integrated aggregated data to the remote second-level cache all at once; S9, direct rendering: the front end reads standardized sorted data from the remote second-level cache and renders and displays it directly.

2. The method and system for secondary caching and dynamic column alignment of multi-channel test data according to claim 1, characterized in that: The local first-level cache in S1 is implemented using a concurrent hash container, which divides the site yield statistics area, integer data row area, and text data row area. The global site identifier set is implemented using a concurrent hash set, which uniformly stores all online test channel identifiers. Each partition can be read and written independently without blocking each other.

3. The method and system for secondary caching and dynamic column alignment of multi-channel test data according to claim 2, characterized in that: In S2, each ground contact test data point is used to retrieve the site yield object using the channel identifier as the key. The total number of tests, the number of qualified tests, and the number of failed tests are atomically accumulated, and the count indicators of the corresponding integer statistical rows for hard classification and soft classification are updated synchronously.

4. The method and system for secondary caching and dynamic column alignment of multi-channel test data according to claim 3, characterized in that: When a new channel identifier is added to the global site set in S3, it is determined to be a new channel. All historical integer rows in the local database are traversed to perform zero-padding operation if the key does not exist. Text rows are traversed to fill in the default display value according to the type. There is no need to temporarily fill in the field during the query stage.

5. The method and system for secondary caching and dynamic column alignment of multi-channel test data according to claim 4, characterized in that: The S4 uses a high-precision decimal arithmetic class to perform yield calculation, sets a fixed decimal precision and a rounding mode, and uses the arithmetic mean of the yield of each channel as the overall yield of the whole machine to avoid the defect of loss of precision in floating-point arithmetic. The S5 sets an integer row encapsulation class, with an internal ordered hash table to store channel values, and achieves concurrent lock-free counting through merging atomic operations; the text row distinguishes between two types of storage structures: yield text and category title text.

6. The method and system for secondary caching and dynamic column alignment of multi-channel test data according to claim 5, characterized in that: The S6 sets column sorting weights: title weight -1, total weight 0, and weights for each test channel are assigned in ascending order by number. When outputting, ordered key-value pairs are generated in ascending order of weights to ensure that the order of JSON fields is fixed and consistent.

7. The method and system for secondary caching and dynamic column alignment of multi-channel test data according to claim 6, characterized in that: When S7 constructs hard and soft category summary data, it directly traverses the existing data in the local first-level cache and assembles it in real time, without opening a separate cache to store the category statistics data, thus reducing memory usage.

8. The method and system for secondary caching and dynamic column alignment of multi-channel test data according to claim 7, characterized in that: After all the grounding test data in a single batch of S8 is processed, only a single network serialization and write request is initiated. The site summary data and the full-dimensional statistical data are stored in two independent keys in the remote cache, reducing network IO and serialization overhead.

9. A semiconductor multi-channel parallel test data secondary cache and dynamic column alignment system, used to execute the semiconductor multi-channel parallel test data secondary cache and dynamic column alignment method according to claim 8, characterized in that, include: Includes: local first-level cache module, dynamic column alignment module, thread-safe data encapsulation module, high-precision yield calculation module, data standardization and sorting module, data redundancy removal and construction module, and remote second-level cache asynchronous refresh module; The local first-level cache module is divided into site yield partition, integer data partition, text data partition, and global site identifier set. It is used to build a local memory concurrent cache storage architecture. Through multi-partition isolated storage, test statistics data, numerical data, and text display data are classified and read and written independently. The global site identifier set is used to collect all online test channel identifiers in real time. The local first-level cache module interacts bidirectionally with the dynamic column alignment module, the thread-safe data encapsulation module, and the data redundancy removal and construction module. The dynamic column alignment module is configured with a new channel registration unit and a historical row backfilling execution unit. The new channel registration unit is used to monitor the global site identifier set in real time, identify newly added unregistered test channels and complete the registration. The historical row backfilling execution unit is used to trigger the operation of zeroing all historical integer data rows and default value filling of text data rows in the local first-level cache. It completes the automatic alignment of multi-channel data columns in the cache preprocessing stage, replacing the inefficient method of temporarily filling fields at the front end. The thread-safe data encapsulation module includes an integer row encapsulation unit and a text row storage unit. The integer row encapsulation unit is used to encapsulate an ordered hash table data structure and realizes multi-threaded lock-free count updates through atomic merging operations. The text row storage unit is used to classify and store yield display text and category title text, and isolate numerical calculation and text display logic. The high-precision yield calculation module is used to load preset high-precision decimal operation rules, fixed decimal precision and rounding mode, and independently complete the calculation and solution of single-channel test yield and overall machine yield, abandoning the traditional ordinary floating-point operation mode and avoiding long-term data accumulation. The data standardization and sorting module is used to pre-store fixed data column weight sorting rules, classify the title field, total summary field, and data fields of each channel according to weight, sort all cached output fields uniformly according to the weight ascending order rule, generate ordered key-value pairs, and realize the standardization and unification of the order of all output JSON data fields; The data redundancy removal module is used to traverse the original data of each partition of the local first-level cache in real time, and assemble hard failure and soft failure classification and summary statistics online. It does not require a separate independent cache to store the summary data, and reuses existing cache resources to complete data aggregation. The remote secondary cache asynchronous refresh module establishes a data connection with the data redundancy removal and construction module. After all test data in a single batch has been processed and assembled, it performs a single unified serialization and asynchronous network write operation, storing the site summary data and full-dimensional detailed data into independent keys of the remote secondary cache, which greatly reduces the number of network I / O operations and serialization overhead.

Images