AI-driven context-aware long connection test method and system for semiconductor intelligent manufacturing

Abstract

The application discloses an AI-driven context-aware long connection test method and system for semiconductor intelligent manufacturing, comprising: receiving a natural language instruction, dynamically compiling it into a test behavior tree containing a message template, asynchronous waiting and context transmission through a natural language processing engine; building a key-value life cycle table, automatically extracting parameters and intelligently injecting subsequent requests by comparing the unique value of the returned message body, realizing cross-message context management; establishing a mapping relationship between events and trigger actions, writing target message features into a filter whitelist when registering asynchronous waiting conditions, and realizing multi-task concurrent listening and dynamic filtering combined with a coroutine or event loop mechanism; monitoring the connection state, dynamically adjusting the detection interval according to real-time network indicators when the connection is disconnected, and executing an adaptive reconnection strategy. The application can effectively solve the problem of asynchronous message post-arrival confusion and multi-device context confusion, and significantly improve the stability and automation level of long connection testing.

Description

Technical Field

[0001] This invention relates to the field of software automated testing technology, and in particular to an AI-driven context-aware long-connection testing method and system for semiconductor intelligent manufacturing. Background Technology

[0002] As semiconductor manufacturing evolves towards intelligence, massive real-time interactions exist between the MES (Manufacturing Execution System), EAP (Equipment Automation System), and vFab (Digital Twin Simulation and Verification Platform) within wafer fabs. WebSocket, as a key long-connection protocol for these core business systems, is responsible for real-time status reporting of critical equipment such as lithography machines, lot transfer, and asynchronous material scheduling instructions. However, existing technologies have significant shortcomings in the field of high-concurrency interface testing in semiconductor manufacturing: 1. Difficulty in maintaining the stability of long-term connections: Network fluctuations in the wafer fab workshop or EAP / MES server upgrades and restarts can easily lead to connection interruptions. Existing tools mostly use fixed-time retries and lack strategies to adaptively adjust based on real-time network indicators, making it difficult to meet the testing needs of semiconductor continuous production simulation.

[0003] 2. Difficulty in controlling the timing of complex asynchronous business processes: Semiconductor device interactions are highly asynchronous. Traditional synchronous testing frameworks can only write request sequences in a fixed order, and cannot express the complex wafer fab business logic of "waiting + condition judgment".

[0004] 3. Parameter confusion under multi-machine concurrency: Existing tools cannot automatically infer the scope of parameters. In test scenarios simulating the concurrent operation of dozens of lithography machines, the extraction of cross-message parameters often relies on manually writing complex regular expression matching rules, which can easily lead to message confusion and assertion failures when multiple devices interact in parallel.

[0005] 4. Severe interference from massive amounts of equipment messages: Semiconductor factories contain numerous devices, and the testing platform receives a massive amount of broadcast messages instantly. Existing testing tools generally lack dynamic filtering mechanisms and natural language-driven capabilities, making it difficult for testers to accurately extract data from specific machines using natural language, and they are easily overwhelmed by irrelevant and interfering information streams. Summary of the Invention

[0006] The purpose of this invention is to effectively solve the problems of asynchronous messages arriving late and the confusion of contexts across multiple devices, and to significantly improve the stability and automation of long connection testing.

[0007] To achieve the above objectives, this invention provides an AI-driven context-aware long-connection testing method for semiconductor intelligent manufacturing, comprising the following steps: S1. Receive natural language instructions and dynamically compile the natural language instructions into an asynchronous execution flow with condition triggering through a natural language processing engine. The asynchronous execution flow is represented as a test behavior tree, which includes message template generation, asynchronous waiting condition judgment, and cross-message context passing. S2. Construct a key-value lifecycle table, determine the context relationship of the message by comparing the unique values ​​of the returned message body, automatically extract the parameters in the returned message body and intelligently inject them into subsequent requests to achieve cross-message context parameter lifecycle management; S3. Establish a mapping relationship between events and triggering actions. When registering the asynchronous waiting conditions, automatically write the target message characteristics into the filter whitelist and realize multi-task concurrent listening and dynamic message filtering through coroutines or event loop mechanisms. S4. Monitor connection status. When a connection loss is detected, dynamically adjust the reconnection detection interval based on real-time network metrics to execute an adaptive intelligent reconnection strategy.

[0008] In one embodiment of the present invention, in step S1, the step of dynamically compiling the natural language instructions into an asynchronous execution flow with conditional triggering via a natural language processing engine specifically includes: Load the pre-built domain dictionary for semantic parsing; The time unit and device number parameters in the natural language instructions are semantically constrained to ensure consistency with the context.

[0009] In one embodiment of the present invention, in step S2, the cross-message context parameter lifecycle management specifically includes: A dedicated key-value lifecycle table is generated when the test scenario begins execution; The association range of the parameters is automatically inferred based on the unique value, so that the extracted parameters are only effective in the target device session, and the key-value lifecycle table is destroyed after the test scenario is completed.

[0010] In one embodiment of the present invention, in step S3, the management mechanism of the filter whitelist is as follows: The filter whitelist is created when the test scenario begins execution; Upon receiving a registration response matching the target message characteristics, the whitelist record is deleted; if the asynchronous waiting condition times out, the business logic is deemed abnormal and the test is interrupted.

[0011] In one embodiment of the present invention, step S4, which involves dynamically adjusting the reconnection detection interval based on real-time network metrics, specifically includes: Obtain the normalized RTT jitter rate and normalized packet loss rate of the current network; Calculate the network quality score using the following formula:

[0012] in, This represents the network quality score. This represents the normalized RTT jitter rate. This represents the normalized packet loss rate. Indicates the first weight. Indicates the second weight; The reconnection detection interval is determined using the following formula:

[0013] in, Indicates the reconnection detection interval. Indicates the minimum interval. Indicates the maximum interval.

[0014] In one embodiment of the present invention, before generating the message template, a step of constructing a data dictionary is further included: Import the preset data pattern in the interface communication specification as the static source; Historical interaction messages are extracted and clustered to generate dynamic sources, and the data dictionary is constructed accordingly. The step of extracting historical interaction messages and clustering them to generate dynamic sources specifically includes: The hierarchical historical message data is flattened, and the text features of fields and values ​​are extracted; The core field names and values ​​are calculated and identified by a feature weight statistical algorithm, redundant fields are filtered, and a structured data model is constructed after field type analysis.

[0015] In one embodiment of the present invention, step S3, which involves implementing concurrent multi-task listening through a coroutine or event loop mechanism, specifically includes: When a user enters multiple commands simultaneously, create an independent coroutine for each request and register a dedicated listener for each request. When a response message is received, the system uses a coroutine isolation design to extract a universally unique identifier or keyword feature from the response message and compare it with the filter whitelist to determine the context of the current response message.

[0016] In one embodiment of the present invention, in step S4, the implementation of the network adaptive intelligent reconnection strategy further includes: pausing the test when a connection loss is detected; continuing the test after the connection is restored; and terminating the test when the number of reconnections reaches the configured upper limit.

[0017] This invention also provides an AI-driven context-aware long-connection testing system for intelligent semiconductor manufacturing, capable of implementing the methods described above, the system comprising: Execution Flow Compilation Module: This module receives natural language instructions and dynamically compiles them into conditionally triggered asynchronous execution flows through a natural language processing engine. The asynchronous execution flows are represented as test behavior trees, which include message template generation, asynchronous wait condition judgment, and cross-message context passing. Context Management Module: Used to build key-value lifecycle tables, determine the context relationship of messages by comparing the unique values ​​of the returned message body, automatically extract parameters from the returned message body and intelligently inject them into subsequent requests to achieve cross-message context parameter lifecycle management; Concurrent listening module: used to establish the mapping relationship between events and triggering actions. When registering the asynchronous waiting conditions, it automatically writes the target message characteristics into the filter whitelist and realizes multi-task concurrent listening and dynamic message filtering through coroutines or event loop mechanisms. Connection Autonomy Module: Used to monitor connection status. When a connection loss is detected, it dynamically adjusts the reconnection detection interval based on real-time network metrics to execute a network-adaptive intelligent reconnection strategy.

[0018] A computer device, comprising: At least one processor; A memory that is communicatively connected to the at least one processor; The memory stores a computer program that can be executed by the at least one processor, which, when executed by the processor, enables the processor to perform the steps of the method as described in any of the preceding descriptions.

[0019] The present invention has the following beneficial effects: This invention provides a highly efficient and stable long-connection automated testing solution for the complex interactive scenarios in semiconductor smart manufacturing workshops. First, by introducing an NLP parsing engine with a pre-built wafer fab-specific terminology library, this invention can dynamically compile natural language commands into asynchronous execution flows containing conditional triggers. This adapts to the asynchronous bidirectional interactive features of MES dispatching and EAP automated scheduling, enabling testers to perform business process testing without writing complex code. Second, when dealing with high-concurrency testing across multiple machines, the system innovatively constructs a key-value lifecycle table. Based on core identifiers, it automatically determines the message context and accurately transmits cross-message parameters, thus solving the message confusion problem when multiple devices are running concurrently. Furthermore, considering the massive amount of broadcast messages in wafer fabs, a dynamic message filtering mechanism and AI intent classification are introduced. The testing system can automatically write target machine characteristics into a whitelist based on commands, and in real time block interference data from irrelevant devices throughout the plant, allowing R&D testers to focus highly on anomaly monitoring and status tracking of target devices. Finally, this invention abandons the traditional fixed-frequency reconnection and adopts a network adaptive intelligent reconnection strategy, which can dynamically adjust the reconnection interval according to the real-time network quality score, scientifically maintain the session state, and ensure the stable execution of semiconductor business continuity testing tasks. Attached Figure Description

[0020] Figure 1 A flowchart of an AI-driven context-aware long-connection testing method for semiconductor intelligent manufacturing according to an embodiment of the present invention is disclosed; Figure 2 A block diagram of an AI-driven context-aware long-connection test system for semiconductor intelligent manufacturing, according to an embodiment of the present invention, is disclosed.

[0021] Figure Labels

[0022] 1. Execution Stream Compilation Module; 2. Context Management Module; 3. Concurrency Monitoring Module; 4. Connection Autonomy Module; 5. Data Dictionary Module; 6. WS Execution Module. Detailed Implementation

[0023] To make the objectives, technical solutions, and advantages of this invention clearer, the invention will be further described in detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are for illustrative purposes only and are not intended to limit the invention.

[0024] In the first embodiment of the present invention, as Figure 1 As shown, an AI-driven context-aware long-connection testing method for intelligent semiconductor manufacturing is demonstrated, including the following steps: S1. Receive natural language instructions and dynamically compile them into an asynchronous execution flow with conditional triggering through the natural language processing engine. The asynchronous execution flow is represented as a test behavior tree, which includes message template generation, asynchronous wait condition judgment, and cross-message context passing. S2. Construct a key-value lifecycle table, determine the context relationship of the message by comparing the unique values ​​of the returned message body, automatically extract the parameters in the returned message body and intelligently inject them into subsequent requests to achieve cross-message context parameter lifecycle management; S3. Establish a mapping relationship between events and triggering actions. When registering asynchronous waiting conditions, automatically write the target message characteristics into the filter whitelist and realize multi-task concurrent listening and dynamic message filtering through coroutines or event loop mechanisms. S4. Monitor connection status. When a connection loss is detected, dynamically adjust the reconnection detection interval based on real-time network metrics to execute an adaptive intelligent reconnection strategy.

[0025] In this embodiment, in step S1, the natural language instructions are dynamically compiled into an asynchronous execution flow with conditional triggering by the natural language processing engine, specifically including: Load the pre-built domain dictionary for semantic parsing; Semantic constraint validation is performed on the time unit and device number parameters in natural language instructions to ensure consistency with the context.

[0026] In this embodiment, step S2, the cross-message context parameter lifecycle management, specifically includes: A dedicated key-value lifecycle table is generated when the test scenario begins execution; The system automatically infers the associated range of parameters based on unique values, ensuring that the extracted parameters are only effective within the target device session, and destroys the key-value lifecycle table after the test scenario is completed.

[0027] In this embodiment, the management mechanism of the filter whitelist in step S3 is as follows: Create a filter whitelist when the test scenario begins execution; Upon receiving a registration response matching the target message characteristics, delete the whitelist record; if the asynchronous wait condition times out, determine that the business logic is abnormal and interrupt the test.

[0028] In this embodiment, step S4 involves dynamically adjusting the reconnection detection interval based on real-time network metrics, specifically including: Obtain the normalized RTT jitter rate and normalized packet loss rate of the current network; Calculate the network quality score using the following formula:

[0029] in, Indicates network quality score, This represents the normalized RTT jitter rate. This represents the normalized packet loss rate. Indicates the first weight. Indicates the second weight; The reconnection detection interval is determined using the following formula:

[0030] in, Indicates the reconnection detection interval. Indicates the minimum interval. Indicates the maximum interval.

[0031] In this embodiment, before generating the message template, a step of constructing a data dictionary is also included: Import the preset data pattern in the interface communication specification as the static source; Historical interaction messages are extracted and clustered to generate dynamic sources, and a data dictionary is constructed.

[0032] Extracting historical interaction messages and clustering them to generate dynamic sources, specifically including: The hierarchical historical message data is flattened, and the text features of fields and values ​​are extracted; The core field names and values ​​are calculated and identified by a feature weight statistical algorithm, redundant fields are filtered, and a structured data model is constructed after field type analysis.

[0033] In this embodiment, step S3 implements concurrent listening for multiple tasks through a coroutine or event loop mechanism, specifically including: When a user enters multiple commands simultaneously, create an independent coroutine for each request and register a dedicated listener for each request. When a response message is received, the coroutine isolation design extracts the universally unique identifier or keyword features from the response message and compares them with the filter whitelist to determine the context of the current response message.

[0034] In this embodiment, step S4, which implements a network adaptive intelligent reconnection strategy, further includes: pausing the test when a connection loss is detected; continuing the test after the connection is restored; and terminating the test when the number of reconnections reaches the configured upper limit.

[0035] This invention also provides an AI-driven context-aware long-connection testing system for intelligent semiconductor manufacturing, capable of implementing any of the above methods. The system includes: Execution Flow Compilation Module 1: This module receives natural language instructions and dynamically compiles them into conditionally triggered asynchronous execution flows through the natural language processing engine. The asynchronous execution flow is represented as a test behavior tree, which includes message template generation, asynchronous wait condition judgment, and cross-message context passing. Context Management Module 2: Used to build a key-value lifecycle table, determine the context relationship of the message by comparing the unique values ​​of the returned message body, automatically extract the parameters in the returned message body and intelligently inject them into subsequent requests to achieve cross-message context parameter lifecycle management; Concurrent listening module 3: It is used to establish the mapping relationship between events and triggering actions. When registering asynchronous waiting conditions, it automatically writes the target message characteristics into the filter whitelist and realizes multi-task concurrent listening and dynamic message filtering through coroutines or event loop mechanisms. Connection Autonomy Module 4: Used to monitor connection status. When a connection loss is detected, it dynamically adjusts the reconnection detection interval based on real-time network metrics to execute a network-adaptive intelligent reconnection strategy.

[0036] A computer device, comprising: At least one processor; Memory that is communicatively connected to at least one processor; The memory stores a computer program that can be executed by at least one processor, which, when executed by the processor, enables the processor to perform the steps of any of the methods described above.

[0037] In the second embodiment of the present invention, as Figure 2 The diagram illustrates the overall system architecture and the steps of each specific module: 1. Execution Flow Compilation Module 1: Execution Flow Compilation Module 1 is an NLP parsing engine that compiles natural language instructions through domain adaptation and adopts a two-stage parsing approach.

[0038] (1) Domain dictionary injection step: Pre-configure a terminology library for a specific domain, such as a wafer fab terminology library (e.g., "photoresist=PHOTO_RESIST"). The engine needs to load this domain dictionary to avoid the general language model generating invalid test instructions.

[0039] (2) Semantic constraint verification steps: Perform constraint verification on key parameters, such as time unit (seconds / minutes), device number, etc. For example, when generating "timeout=30" for "not delivered in 30 seconds", the consistency of the time unit with the context is automatically verified. Since the time units defined in different interfaces in the interface specification are different, some are in seconds and some are in milliseconds, AI may sometimes mistakenly confuse the units of interface parameters. This verification can prevent AI illusions from causing test logic errors.

[0040] (3) Dynamic compilation steps: Natural language instructions (such as "fail if no response is received within 30 seconds") are automatically compiled into an asynchronous execution flow with conditional triggers, i.e., a test behavior tree, instead of generating static scripts. Its advantage lies in the fact that traditional Postman and JMeter can only write fixed-order request sequences and cannot express "wait + condition judgment". If only NLP is used to generate message content but asynchronous waiting logic is not handled, complex business process testing cannot be achieved. This behavior tree includes: The first step is to generate a message template (e.g., {"cmd":"replenish","machine_id":${id},"material":${type}}); The second step is to check the asynchronous waiting conditions (e.g., WAIT_FOR("delivery_success",timeout=30s,filter={"machine_id":"84"})). The third step is to pass messages across the message context (e.g., extract D123 from {"delivery_id":"D123"} and inject it into subsequent requests).

[0041] The aforementioned execution flow compilation module addresses the system's challenge of handling complex asynchronous material handling scheduling within a wafer fab. In real-world environments, AMHS (Automated Material Handling Systems) often require waiting time when transporting photoresist. This module can understand and compile semiconductor manufacturing instructions such as "equipment number" and "wait time," enabling testing tools to realistically simulate the material delivery sequence within the workshop, rather than simply performing interface connectivity tests.

[0042] 2. Context Management Module 2: Context Management Module 2 constructs a key-value lifecycle table, automatically extracts parameters from the response, and intelligently injects them into subsequent requests. Manually writing regular expressions to extract parameters is error-prone and cannot handle multi-device parallel scenarios, while existing tools require manual configuration of variable replacement rules and cannot automatically infer scope.

[0043] (1) Extraction and Injection Steps: By comparing the unique value "machine_id" in the returned message body, the context of the message is determined, the "delivery_id" in the returned message body is extracted, and the "delivery_id" field of the next test case request is replaced to ensure that request A will not be replied to by B. A key-value lifecycle table is generated when the test scenario starts execution and destroyed after execution. Specifically, when {"material_id": "M100"} is received, "material_id=M100" is automatically bound.

[0044] (2) Isolation and Anti-Confusion Steps: Determine "machine_id" as the feature field that can be used for isolation. Because the uniqueness of the feature field is specified in the requirements document, the AI ​​will be clearly informed when writing the knowledge base that these keywords can be used to distinguish contexts. If subsequent instructions contain {"machine_id": "84"}, they will only take effect in the session of that machine, thus solving the problem of message confusion across multiple devices. Traditional tools require manual configuration of variable replacement rules and cannot automatically infer the scope. Manually writing regular expressions is prone to errors and cannot handle parallel processing of multiple devices.

[0045] This module is crucial for supporting EAP (Equipment Automation Program) systems that support the concurrent operation of hundreds of machines. Interactions between semiconductor manufacturing equipment rely heavily on accurate context information, such as machine_id and delivery_id. Through automated context management, the test platform can seamlessly handle requests and responses initiated simultaneously by multiple devices, avoiding instruction mismatches during production simulations of high concurrency across the entire plant.

[0046] 3. Data Dictionary Module 5: In order to enable the AI ​​parsing engine to accurately understand business intent and generate structured test messages, this system has designed a dual-source construction mechanism for the data dictionary, which extracts data from historical data and data generated during the testing process.

[0047] (1) Dual-source construction mechanism: Static source import steps: The system supports directly importing the Schema from the standard API documentation as the static source of the base dictionary.

[0048] Dynamic Source Generation Steps (TF-IDF Clustering): For the large amount of unstructured data accumulated historically, the system generates dynamic sources by clustering historical messages. Further, the system uses the TF-IDF algorithm to transform historical messages into a structured schema. The core process of converting JSON content into a schema via TF-IDF is: JSON flattening—field / value text extraction—TF-IDF calculation—field type analysis—schema construction.

[0049] Core Feature Extraction Steps: The core role of TF-IDF in this process is to identify core fields (i.e., high TF-IDF field names) and core value features (i.e., high TF-IDF field values), and filter out useless redundant fields. Furthermore, this algorithm can automatically identify {"status":"RUNNING"} as the key status feature word.

[0050] (2) Automatic version evolution management mechanism: During long-term test execution, the system has the ability to automatically manage versions. When a change is detected in the interface message structure (for example, a "temperature" field is suddenly added to the response structure), the system will automatically trigger a dictionary update prompt to ensure that the data dictionary mastered by the AI ​​is always consistent with the actual interface specification.

[0051] (3) Non-blocking waiting mechanism: Multiple timeout tasks are handled by a coroutine pool, which is more effective than the traditional solution of blocking the main thread with sleep().

[0052] 4. Concurrent Listening Module 3: This module uses a coroutine pool to handle multiple concurrent tasks and registers a dedicated listener and filter whitelist for each request to achieve non-blocking waiting.

[0053] (1) Message-Instruction Mapping and Concurrent Non-Blocking: Establish a mapping relationship of {event: trigger action}, and implement multi-task concurrent listening through coroutines or event loops without blocking the main thread. Compared with the traditional solution of using "Thread.sleep()" or timers, the coroutine pool handles multiple timeout tasks with less resource consumption, higher accuracy and better performance. When the user inputs multiple executions at the same time, the AI ​​creates an independent coroutine for each request and registers a dedicated listener.

[0054] (2) Dynamic message filtering and intent classification: Context parameter association and message filtering work together.

[0055] Filtering steps: When an asynchronous wait condition is registered, the target message characteristics are automatically written to the filter whitelist. This whitelist is created when the test scenario starts and deleted upon receiving a registration response; if a timeout occurs, it indicates an exception in the business logic, and the test is interrupted.

[0056] Real-time filtering process: Users specify "only process machines 84 / 96," and AI will filter irrelevant messages in real time to reduce interference in the information flow. If traditional WebSocat tools lack this mechanism, users would be overwhelmed by massive amounts of messages in high-concurrency scenarios, requiring additional script development. Message filtering combined with automatic isolation avoids the problem of lengthy manual identification times.

[0057] Semiconductor manufacturing workshops are typical high-concurrency information flow environments, with hundreds of devices broadcasting their status every second. This concurrent monitoring and dynamic filtering mechanism enables the testing platform to accurately capture data interactions of specific business lines or specific clusters within the vast network simulating the operation of the entire wafer fab.

[0058] 5. Connecting to Autonomous Module 4: Abandoning fixed-time retries, the reconnection interval is dynamically adjusted based on real-time network metrics. The higher the network jitter and packet loss rate, the shorter the detection interval.

[0059] Calculate the network quality score using the following formula:

[0060] in, Indicates network quality score, This represents the normalized RTT jitter rate. This represents the normalized packet loss rate. Indicates the first weight. This represents the second weight. Further, the network quality score... The value ranges from 0 to 1, where 0 represents the range and 1 represents the excellent. Furthermore, in the formula... and The optimal value is 0.5, but it can be adjusted according to business needs. If more attention is paid to packet loss rate, its weight can be increased.

[0061] The reconnection detection interval is determined using the following formula:

[0062] in, Indicates the reconnection detection interval. Indicates the minimum interval. Indicates the maximum interval.

[0063] When a connection loss is detected, the test is paused and will continue after the connection is restored; the test will terminate when the number of reconnections reaches the configurable limit.

[0064] 6. WS Execution Module 6: AI can directly call the WebSocket communication protocol interface to automatically maintain heartbeat and interaction information processing. Historical Commands: User commands are saved to the history and can be directly recalled on the page later.

[0065] In the daily operation and maintenance of semiconductor plant facilities and IT infrastructure, momentary disconnections caused by network fluctuations or system upgrades are common. The intelligent reconnection strategy provided by this connectivity autonomy module can maximize the robustness of test tasks during long-term automated regression testing, ensuring that the test system itself will not cause widespread test case execution failures due to minor fluctuations in the workshop network.

[0066] In the third embodiment of the present invention, based on the second embodiment, the overall execution flow of the system architecture testing method is as follows: The first step, Natural Language Parsing and Behavior Tree Compilation: Execution flow compilation module 1, combined with a pre-built domain dictionary, transforms the instruction into an execution behavior tree containing message templates, asynchronous wait conditions, and context passing rules, rather than a static script. During compilation, the NLP parsing engine automatically verifies whether the time units in the instruction conform to the specifications defined in the interface documentation.

[0067] The second step is context initialization: The WS execution module establishes a WebSocket connection based on the target URL. Simultaneously, the context management module 2 creates a dedicated key-value lifecycle table for the current test scenario. If the instruction contains specific machine characteristics, the system will automatically determine the associated scope, ensuring that subsequent parameter extraction is only effective within that machine session.

[0068] Step 3: Message Sending and Listening: The concurrent listening module 3 extracts the instruction format from the data dictionary module 5, fills in the parameters, and sends the request via the WS connection. At this time, the concurrent listening module 3 registers a whitelist feature for this request in the filter. For multiple test cases executed concurrently, the concurrent listening module 3 isolates them through independent coroutines and uses the event loop mechanism to achieve non-blocking waiting without blocking the main thread.

[0069] Step 4: Parameter Extraction and Filtering: Upon receiving a response message, AI filters out irrelevant and interfering information (such as notifications from non-target machines) in real time. The concurrent monitoring module 3 compares the keywords in the returned content with a whitelist to confirm the message's origin. Then, it extracts the target parameters from the response body and updates the key-value lifecycle table for use in subsequent test steps.

[0070] Step 5: Intelligent Reconnection: Throughout the test, the connection autonomous module 4 continuously monitors network quality. If a disconnection occurs, the test automatically pauses, and the connection autonomous module 4 dynamically adjusts the timing of reconnection attempts based on a formula. After the connection is restored, the test resumes from the breakpoint; if the maximum number of reconnection attempts is reached, the test terminates and an error is reported.

[0071] Step 6: Task completion: After the test case is executed or a timeout is triggered, the system outputs the test results, destroys the key-value lifecycle table and filter whitelist corresponding to the scenario, and releases the relevant coroutine resources.

[0072] The above six-step process constitutes a highly automated semiconductor business scenario testing pipeline. From understanding production requirements (natural language parsing), to locking onto the target machine (context initialization), to simulating the sending of control commands (sending and listening), and finally to collecting the execution result feedback from the equipment (parameter extraction and filtering), this closed-loop process is highly aligned with the advancement of smart factory operations and AI-assisted testing, and can greatly improve the efficiency of system integration testing.

[0073] In the fourth embodiment of the present invention, taking the scenario of a wafer fab monitoring the working status of multiple lithography machines as an example, the specific implementation of the AI-driven context-aware long-connection testing method for semiconductor intelligent manufacturing of the present invention in a complex asynchronous business scenario is illustrated. In this scenario, the user directly controls the AI ​​to conduct tests using natural language through a webpage.

[0074] 1. Test task initialization

[0075] The user first enters the command to create a WebSocket test task, specifying the target address. The preferred command is "url is ws: / / 192.168.5.100 / api?lot=12345678". Here, the `lot` parameter refers to a tracking unit in semiconductor manufacturing. By directly using the Lot ID to initialize the test environment, the solution's native support for end-to-end testing of business processes centered on production batches is verified.

[0076] After receiving the input, the AI ​​uses NLP to parse the content and calls the WS execution module 6 to automatically generate a WebSocket connection based on the URL.

[0077] After a WebSocket connection is successfully established, the system displays the result to the user on the page; if it fails, an error log is displayed.

[0078] After the connection is established, the AI ​​continuously monitors all interaction information. If a disconnection occurs, the system will reconnect based on the network status and display a message on the page: "Disconnection occurred, now restored."

[0079] 2. Trigger the test task

[0080] This step also includes a dynamic message filtering mechanism. Since the wafer fab monitors a large number of lithography machines, the WebSocket channel receives a large number of notification messages from other machines. To reduce interference, users can tell the AI ​​in natural language: "Only process information from machine number 84, and block the others." After receiving this instruction, the AI ​​will establish a dynamic message filter in real time, allowing only messages containing information from machine number 84 to pass through, thereby reducing the interference of irrelevant information to the user.

[0081] AI uses NLP to parse the content, extracts the "check status" instruction format from the data dictionary, changes the instruction number field to "84", and then sends the instruction content via a WebSocket connection. After the response message is returned, the content is analyzed and compared with the content extracted from the data dictionary, and the test results are displayed on the page.

[0082] 3. Instruction parsing and semantic constraint verification

[0083] The user inputs a complex business test command: "Transport the photoresist to lithography machine No. 84. If it is not delivered within 30 seconds, consider it a failure. If the delivery is successful, notify the main console to update the status of No. 84."

[0084] (1) Instruction parsing: The AI ​​uses NLP to parse the content and extracts the instruction format of "replenishing materials" from the pre-built data dictionary. The system dynamically modifies the instruction number field to "84", modifies the material number to "photoresist", and sends the instruction content via WebSocket connection.

[0085] (2) Semantic Constraint Verification: When parsing the time condition "30 seconds", the NLP engine performs context consistency verification based on the domain dictionary and interface documentation. Because the time units of different interfaces may be different, this verification mechanism can prevent A1 from mistakenly confusing the time units of interface parameters, thereby preventing invalid or erroneous test logic.

[0086] This scenario simulates typical cross-system collaborative scheduling in semiconductor manufacturing: it involves not only material management (transporting photoresist), but also timeout determination and state synchronization. This complex multi-step condition-triggered test ensures that the MES dispatch strategy, when reaching the specific execution layer, not only delivers correct instructions, but also meets the stringent timing requirements of the workshop.

[0087] 4. Asynchronous waiting and cross-message context passing

[0088] For the logical branches in the above instructions, the system generates an asynchronous execution flow with conditional triggering: "Conditional failure branch: The system registers an asynchronous wait condition with a timeout of 30 seconds." If no "delivery successful" response message is received within 30 seconds, the system determines the test has failed and reports an error directly. Once a "delivery successful" response is received, the system triggers the next level execution flow, "Notify the master control station." At this time, the AI ​​automatically extracts the tracking number "track_id" from the context of the "delivery successful" response and replaces it in the "track_id" field of the "Notify the master control station" instruction, achieving intelligent parameter injection across messages.

[0089] 5. Concurrency processing and coroutine isolation mechanisms

[0090] WebSocket is an asynchronous bidirectional transmission protocol, so when performing complex use cases such as replenishing materials, which have a waiting period of up to 30 seconds, users can still input other commands concurrently, such as executing "check the status of lithography machine No. 84".

[0091] In response to the "Check Status" command, the AI ​​extracts the format from the data dictionary, replaces the number with 84, and sends it. After the response is returned, it analyzes the content and compares it with the dictionary, then displays the results.

[0092] To distinguish the origin of various response messages in concurrent scenarios, the system employs a coroutine isolation design. When a response is received, the AI ​​first uses the "uuid" and "filter" parameters in the response message to determine which previous instruction the returned content belongs to. If the message does not contain a "uuid," the system compares it using other keyword features (such as "material_id") in conjunction with a filter whitelist. For example, when registering a test case for a certain lot, the request includes the keywords "material_id" and "eqp_id." If the returned response content contains not only these two IDs but also "lot_id," the system can determine the context of the response message.

[0093] The system locates messages by intelligently identifying multiple business characteristics, demonstrating strong domain adaptability. This is not only applicable to standard SECS / GEM protocol testing, but also perfectly compatible with the automated transformation and joint testing of various non-standard old equipment.

[0094] The present invention has the following beneficial effects: This invention provides a highly efficient and stable long-connection automated testing solution for the complex interactive scenarios in semiconductor smart manufacturing workshops. First, by introducing an NLP parsing engine with a pre-built wafer fab-specific terminology library, this invention can dynamically compile natural language commands into asynchronous execution flows containing conditional triggers. This adapts to the asynchronous bidirectional interactive features of MES dispatching and EAP automated scheduling, enabling testers to perform business process testing without writing complex code. Second, when dealing with high-concurrency testing across multiple machines, the system innovatively constructs a key-value lifecycle table. Based on core identifiers, it automatically determines the message context and accurately transmits cross-message parameters, thus solving the message confusion problem when multiple devices are running concurrently. Furthermore, considering the massive amount of broadcast messages in wafer fabs, a dynamic message filtering mechanism and AI intent classification are introduced. The testing system can automatically write target machine characteristics into a whitelist based on commands, and in real time block interference data from irrelevant devices throughout the plant, allowing R&D testers to focus highly on anomaly monitoring and status tracking of target devices. Finally, this invention abandons the traditional fixed-frequency reconnection and adopts a network adaptive intelligent reconnection strategy, which can dynamically adjust the reconnection interval according to the real-time network quality score, scientifically maintain the session state, and ensure the stable execution of semiconductor business continuity testing tasks.

[0095] The embodiments described above are merely further illustrations of the present invention and are not intended to limit the present invention in any other way. The present invention may have many other embodiments. Without departing from the spirit and essence of the present invention, those skilled in the art can make various corresponding modifications and changes based on the present invention, but all such modifications and changes should fall within the protection scope of the present invention.

Claims

1. An AI-driven context-aware long-connection testing method for intelligent semiconductor manufacturing, characterized in that, Includes the following steps: S1. Receive natural language instructions and dynamically compile the natural language instructions into an asynchronous execution flow with condition triggering through a natural language processing engine. The asynchronous execution flow is represented as a test behavior tree, which includes generating message templates, asynchronous waiting condition judgment, and cross-message context passing. S2. Construct a key-value lifecycle table, determine the context relationship of the message by comparing the unique values ​​of the returned message body, automatically extract the parameters in the returned message body and intelligently inject them into subsequent requests to achieve cross-message context parameter lifecycle management; S3. Establish a mapping relationship between events and triggering actions. When registering the asynchronous waiting conditions, automatically write the target message characteristics into the filter whitelist and realize multi-task concurrent listening and dynamic message filtering through coroutines or event loop mechanisms. S4. Monitor connection status. When a connection loss is detected, dynamically adjust the reconnection detection interval based on real-time network metrics to execute an adaptive intelligent reconnection strategy.

2. The method according to claim 1, characterized in that, In step S1, the dynamic compilation of the natural language instructions into an asynchronous execution flow with conditional triggering via a natural language processing engine specifically includes: Load the pre-built domain dictionary for semantic parsing; The time unit and device number parameters in the natural language instructions are semantically constrained to ensure consistency with the context.

3. The method according to claim 1, characterized in that, In step S2, the cross-message context parameter lifecycle management specifically includes: A dedicated key-value lifecycle table is generated when the test scenario begins execution; The association range of the parameters is automatically inferred based on the unique value, so that the extracted parameters are only effective in the target device session, and the key-value lifecycle table is destroyed after the test scenario is completed.

4. The method according to claim 1, characterized in that, In step S3, the management mechanism for the filter whitelist is as follows: The filter whitelist is created when the test scenario begins execution; Upon receiving a registration response matching the target message characteristics, the whitelist record is deleted; if the asynchronous waiting condition times out, the business logic is deemed abnormal and the test is interrupted.

5. The method according to claim 1, characterized in that, In step S4, the step of dynamically adjusting the reconnection detection interval based on real-time network metrics specifically includes: Obtain the normalized RTT jitter rate and normalized packet loss rate of the current network; Calculate the network quality score using the following formula: in, This represents the network quality score. This represents the normalized RTT jitter rate. This represents the normalized packet loss rate. Indicates the first weight. Indicates the second weight; The reconnection detection interval is determined using the following formula: in, Indicates the reconnection detection interval. Indicates the minimum interval. Indicates the maximum interval.

6. The method according to claim 1, characterized in that, Before generating the message template, the process also includes building a data dictionary: Import the preset data pattern in the interface communication specification as the static source; Historical interaction messages are extracted and clustered to generate dynamic sources, and the data dictionary is constructed accordingly. The step of extracting historical interaction messages and clustering them to generate dynamic sources specifically includes: The hierarchical historical message data is flattened, and the text features of fields and values ​​are extracted; The core field names and values ​​are calculated and identified by a feature weight statistical algorithm, redundant fields are filtered, and a structured data model is constructed after field type analysis.

7. The method according to claim 1, characterized in that, In step S3, the implementation of concurrent multi-task listening via coroutines or event loop mechanisms specifically includes: When a user enters multiple commands simultaneously, create an independent coroutine for each request and register a dedicated listener for each request. When a response message is received, the system uses a coroutine isolation design to extract a universally unique identifier or keyword feature from the response message and compare it with the filter whitelist to determine the context of the current response message.

8. The method according to claim 1, characterized in that, In step S4, the implementation of the network adaptive intelligent reconnection strategy further includes: pausing the test when a connection loss is detected; continuing the test after the connection is restored; and terminating the test when the number of reconnections reaches the configured upper limit.

9. An AI-driven context-aware long-connection testing system for intelligent semiconductor manufacturing, characterized in that, The system, capable of implementing the method as described in any one of claims 1 to 8, comprises: Execution Flow Compilation Module: This module receives natural language instructions and dynamically compiles them into conditionally triggered asynchronous execution flows through a natural language processing engine. The asynchronous execution flow is represented as a test behavior tree, which includes message template generation, asynchronous wait condition judgment, and cross-message context passing. Context Management Module: Used to build key-value lifecycle tables, determine the context relationship of messages by comparing the unique values ​​of the returned message body, automatically extract parameters from the returned message body and intelligently inject them into subsequent requests to achieve cross-message context parameter lifecycle management; Concurrent listening module: used to establish the mapping relationship between events and triggering actions. When registering the asynchronous waiting conditions, it automatically writes the target message characteristics into the filter whitelist and realizes multi-task concurrent listening and dynamic message filtering through coroutines or event loop mechanisms. Connection Autonomy Module: Used to monitor connection status. When a connection loss is detected, it dynamically adjusts the reconnection detection interval based on real-time network metrics to execute a network-adaptive intelligent reconnection strategy.

10. A computer device, characterized in that, include: At least one processor; A memory that is communicatively connected to the at least one processor; The memory stores a computer program that can be executed by the at least one processor, which, when executed by the processor, enables the processor to perform the steps of the method as described in any one of claims 1 to 8.

Images