Parallel simulation regression method and system based on cluster server

By classifying and dependency analysis of simulation tasks, generating a target task list, and using the scheduling function of the cluster server for parallel execution, the problem of inefficiency of the existing simulation regression system is solved, and efficient parallel operation and simplification of simulation tasks are achieved. System development.

CN118917262AInactive Publication Date: 2024-11-08YIXING INTELLIGENT (BEIJING) TECHNOLOGY CO LTD
View PDF 0 Cites 11 Cited by

Patent Information

Application Number
CN202411409428.1
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2024-10-10
Publication Date
2024-11-08
Estimated Expiration
Not applicable · inactive patent

AI Technical Summary

Technical Problem

The existing simulation regression systems are inefficient when dealing with multiple task types, and are complex in development, making it difficult to achieve parallel task scheduling, resulting in an extended chip R&D cycle.

Method used

By classifying and dependency analysis of multiple simulation tasks, a target task list is generated, and the scheduling function of the cluster server is used for parallel execution to generate a regression test report.

Benefits of technology

It improves the parallelism and efficiency of simulation tasks, simplifies system development, reduces development difficulty, and is suitable for common simulation tools and cluster server management tools.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN118917262A_ABST
    Figure CN118917262A_ABST
Patent Text Reader

Abstract

The invention relates to the technical field of digital circuit verification, and discloses a parallel simulation regression method and system based on a cluster server, and the method comprises the steps: classifying a plurality of simulation tasks, and obtaining the task type of each simulation task; according to the task type, performing dependency relationship analysis on the plurality of simulation tasks to obtain a task dependency relationship; according to the task dependency relationship, performing arrangement processing on the plurality of simulation tasks to obtain a target task list; delivering the plurality of simulation tasks on the target task list to a cluster server, and running the plurality of simulation tasks through the cluster server to obtain a task running result file; according to the method, the scheduling function of the cluster server is utilized, the parallel simulation regression system is conveniently constructed, the dependency relationship of various types of tasks can be processed, the degree of parallelism of the simulation regression system is increased to the maximum extent, and the method has universality.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] The present invention relates to the technical field of digital circuit verification, and in particular to a parallel simulation regression method and system based on a cluster server. Background Art

[0002] During the chip development process, simulation regression of chip design code is the main means of testing code quality and the core system of chip front-end verification. Through simulation regression results, potential chip design problems can be discovered, so that problems can be located and repaired in a timely manner to avoid irreparable losses after chip tape-out. General simulation regression systems are based on cluster servers, which submit simulation tasks to cluster servers, which execute tasks and write results back to generate simulation results. Based on limited cluster server resources, how to quickly complete simulation regression tasks, thereby accelerating chip development iterations and reducing chip development cycles is the main challenge of simulation regression systems.

[0003] Some common simulation regression systems currently only allow one type of task to be executed at a time, and simulation tasks of multiple types need to be executed separately. In addition, some simulation regression systems, although they can support the execution of multiple types of tasks, require the development of complex intermediate scripts for task scheduling, which increases the difficulty of development and makes it difficult to perfectly solve the problem of task parallel scheduling, thus reducing the execution efficiency of the simulation regression system. Summary of the invention

[0004] The present invention provides a parallel simulation regression method and system based on a cluster server. The present invention utilizes the scheduling function of the cluster server itself to conveniently construct a parallel simulation regression system, which can handle the dependencies of various types of tasks, thereby maximizing the parallelism of the simulation regression system and has universality.

[0005] In a first aspect, the present invention provides a parallel simulation regression method based on a cluster server, and the parallel simulation regression method based on a cluster server comprises: Classify multiple simulation tasks to obtain the task type of each simulation task; According to the task type, performing dependency analysis on the multiple simulation tasks to obtain task dependency; Arrange the plurality of simulation tasks according to the task dependency relationship to obtain a target task list; Delivering multiple simulation tasks on the target task list to a cluster server, and running the multiple simulation tasks through the cluster server to obtain a task running result file; Perform statistical analysis on the task running result file to obtain a regression test report.

[0006] In a second aspect, the present invention provides a parallel simulation regression system based on a cluster server, the parallel simulation regression system based on a cluster server comprising: A classification module is used to classify multiple simulation tasks and obtain the task type of each simulation task; An analysis module, used for performing dependency analysis on the plurality of simulation tasks according to the task type to obtain task dependency; An arrangement module, used for arranging the plurality of simulation tasks according to the task dependency relationship to obtain a target task list; An operation module is used to deliver the multiple simulation tasks on the target task list to the cluster server, and run the multiple simulation tasks through the cluster server to obtain a task running result file; The statistical module is used to perform statistical analysis on the task running result file to obtain a regression test report.

[0007] The third aspect of the present invention provides a computer device, comprising: a memory and at least one processor, wherein the memory stores instructions; the at least one processor calls the instructions in the memory so that the computer device executes the above-mentioned cluster server-based parallel simulation regression method.

[0008] A fourth aspect of the present invention provides a computer-readable storage medium, in which instructions are stored, which, when executed on a computer, enable the computer to execute the above-mentioned cluster server-based parallel simulation regression method.

[0009] In the technical solution provided by the present invention, the parallel simulation regression system of the present invention can efficiently utilize the parallelism and dependency of regression simulation tasks, maximize the parallel operation of simulation tasks, greatly improve regression efficiency, and accelerate verification iteration. At the same time, using the built-in functions of the cluster server management tool, a regression simulation task list can be easily generated and submitted, avoiding complex process script tool development and debugging, and greatly reducing the difficulty of system development. The system can be applied to common simulation tools and cluster server management tools, and has versatility. BRIEF DESCRIPTION OF THE DRAWINGS

[0010] In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the accompanying drawings required for use in the description of the embodiments will be briefly introduced below. Obviously, the accompanying drawings described below are some embodiments of the present invention. For ordinary technicians in this field, other accompanying drawings can be obtained based on these accompanying drawings without paying creative work.

[0011] Figure 1 A schematic diagram of the steps of a parallel simulation regression method based on a cluster server in an embodiment of the present invention; Figure 2 An example diagram of a parallel simulation regression system of the present invention; Figure 3 This is an example diagram of a simulation object in the present invention; Figure 4 This is an example diagram of the simulation stage in the present invention; Figure 5 This is an example diagram of a simulation task in the present invention; Figure 6 An example diagram of an ideal simulation task operation of the present invention; Figure 7 This is an example diagram of a task list of the present invention; Figure 8 It is a structural diagram of a parallel simulation regression system based on a cluster server in an embodiment of the present invention. DETAILED DESCRIPTION

[0012] The embodiment of the present invention provides a parallel simulation regression method and system based on a cluster server. The terms "first", "second", "third", "fourth", etc. (if any) in the specification and claims of the present invention and the above-mentioned drawings are used to distinguish similar objects, and are not necessarily used to describe a specific order or sequence. It should be understood that the data used in this way can be interchanged where appropriate, so that the embodiments described here can be implemented in an order other than that illustrated or described here. In addition, the terms "including" or "having" and any variations thereof are intended to cover non-exclusive inclusions, for example, a process, method, system, product or device that includes a series of steps or units is not necessarily limited to those steps or units that are clearly listed, but may include other steps or units that are not clearly listed or inherent to these processes, methods, products or devices.

[0013] For ease of understanding, the specific process of the embodiment of the present invention is described below. Figure 1 , an embodiment of a parallel simulation regression method based on a cluster server in an embodiment of the present invention includes: It is understandable that the execution subject of the present invention may be a parallel simulation regression system based on a cluster server, or may be a terminal or a server, which is not specifically limited here. The embodiment of the present invention is described by taking a server as the execution subject as an example.

[0014] Step S1, classifying multiple simulation tasks to obtain a task type for each simulation task; Step S2: Analyze the dependency of multiple simulation tasks according to the task type to obtain the task dependency; Step S3: Arrange and process multiple simulation tasks according to task dependencies to obtain a target task list; Step S4: delivering multiple simulation tasks on the target task list to the cluster server, and running the multiple simulation tasks through the cluster server to obtain a task running result file; Step S5: Perform statistical analysis on the task running result file to obtain a regression test report.

[0015] like Figure 2 As shown, the parallel simulation regression system provided by the present invention includes simulation task classification, dependency combing, task list generation, task delivery and regression result analysis. These work together to achieve an efficient parallel simulation regression process. Simulation task classification and dependency combing first process the tasks, and then task list generation creates a task list based on this information. Task delivery submits the task to the cluster server for execution, and finally the regression result analysis processes the execution results and generates a report. The simulation tasks are classified according to the two dimensions of simulation object and simulation stage.

[0016] like Figure 3 As shown in the figure, simulation objects refer to the contents of simulation tasks, which are generally composed of chip design code, chip environment code, and library files. Due to the diversity of verification levels and verification objects, simulation objects are often not single. In addition, even for the same chip design code, in order to improve verification efficiency, the code is often replaced with an empty shell to generate multiple simulation objects.

[0017] like Figure 4 As shown, the simulation stage is related to the specific simulation software. Taking the simulation tool VCS as an example, the simulation process can be divided into two steps or three steps according to the configuration. This embodiment takes the two-step method as an example for explanation, including the compilation stage and the simulation stage. Analyze the dependencies between different simulation tasks. There is no dependency between the simulation tasks of different simulation objects, and they can run in parallel during regression. The dependencies between different simulation tasks of the same simulation object need to be considered in conjunction with the simulation stage. For multiple simulation tasks corresponding to the same simulation object, their compilation stage (ie, the first simulation step) is shared. A regression only needs to start the compilation stage of a simulation task, and other simulation tasks wait for the compilation stage to be completed before proceeding to the subsequent stage. The simulation stage (ie, the second simulation step) of multiple simulation tasks of the same simulation object can be parallel. When the previous compilation stage is completed, the simulation stage of all simulation tasks can run in parallel.

[0018] like Figure 5As shown in the figure, the simulation task example diagram shows the combination of different simulation objects and simulation stages. In this example, there are three different simulation objects (A, B, and C), each of which contains multiple simulation tasks. Each task is divided into a compilation stage and a simulation stage. Generate a simulation task list based on the dependencies of the simulation tasks. It is necessary to combine the simulation queue management tool to arrange the tasks. Mainly follow the following principles: Simulation tasks of different simulation objects run in parallel. Simulation tasks of the same simulation object are processed by stage, shared in the compilation stage, and run in parallel in the simulation stage.

[0019] like Figure 6 As shown, the ideal simulation task running example includes simulation tasks of three groups of simulation objects. Simulation object A includes four simulation tasks, simulation object B includes two simulation tasks, and simulation object C includes three simulation tasks. Since the three groups of simulation tasks belong to different simulation objects, they run in parallel. Submit the task list to the simulation server to start the simulation tasks. The present invention utilizes the built-in functions of the cluster server management tool (such as LSF) to deliver tasks. Taking the LSF tool as an example, it supports the use of a list method for task packaging and delivery. The task list can be submitted through the following command: busub-pack simulation task list.

[0020] like Figure 7 As shown in the figure, the task list example shows the actual task list generated according to the above principles. This list contains all the simulation tasks that need to be executed. Each task has its unique identifier, the simulation object to which it belongs, the execution stage (compilation or simulation), and other necessary execution parameters. The order and organization of the task list reflects the system's handling of task dependencies, ensuring the maximum parallel execution while complying with the necessary execution order. Analyze the simulation result file and generate a simulation report. Based on the result file of the server simulation task run, analyze the status of the simulation task execution, the type of error that occurred, the resources consumed and other data, and output the regression report file. The regression report usually contains information such as regression startup time, simulation time, number of simulation tasks, number of simulation passed tasks, number of simulation failed tasks, number of simulation invalid tasks, regression pass rate, etc.

[0021] In the embodiment of the present invention, the parallel simulation regression system of the present invention can efficiently utilize the parallelism and dependency of the regression simulation tasks, maximize the parallel operation of the simulation tasks, greatly improve the regression efficiency, and accelerate the verification iteration. At the same time, by utilizing the built-in functions of the cluster server management tool, a regression simulation task list can be conveniently generated and submitted, avoiding the complex process script tool development and debugging, and greatly reducing the difficulty of system development. The system can be applicable to common simulation tools and cluster server management tools, and has versatility.

[0022] In a specific embodiment, the process of executing step S1 may specifically include the following steps: Performing simulation object identification on multiple simulation tasks to obtain a simulation object of each simulation task; Perform simulation stage judgment on multiple simulation tasks to obtain the simulation stage of each simulation task; Multiple simulation tasks are classified according to simulation objects and simulation stages to obtain the task type of each simulation task.

[0023] Specifically, the process of classifying multiple simulation tasks in the present invention includes three main steps: simulation object identification, simulation stage judgment and task classification. In the simulation object identification stage, the system analyzes the specific content involved in each simulation task. This usually includes methods such as checking task configuration files, analyzing task parameters or querying task databases. For example, the system identifies that a certain task is for the simulation of the CPU core, while another task is for the simulation of the memory controller. This identification process involves a pattern matching algorithm or a predefined rule set. Simulation stage judgment is to determine which stage of the simulation process each task is in. The simulation process includes a compilation stage and a simulation stage. The system determines the stage of the task by checking the input file type of the task, analyzing the execution command of the task or querying the metadata of the task. For example, if the input of the task is a source code file and the execution command contains a compiler call, then this task is a task in the compilation stage. The system classifies the tasks based on the information of the simulation object and the simulation stage. This involves creating a multidimensional matrix, one dimension of which is the simulation object (such as CPU core, memory controller, etc.) and the other dimension is the simulation stage (such as compilation, simulation, etc.). Each task will be assigned to a specific cell in this matrix.

[0024] In a specific embodiment, the process of executing step S2 may specifically include the following steps: Grouping multiple simulation tasks with the same simulation object to obtain a simulation object task group; The simulation tasks in each simulation object task group are sorted according to the simulation stage to obtain an ordered simulation task group; The simulation tasks in the ordered simulation task group are divided into a compilation phase and a simulation phase to obtain a task set of a shared compilation phase and a parallel simulation phase; The simulation tasks in the shared compilation phase are determined as the pre-dependencies of the tasks in the parallel simulation phase, and the task dependency relationship is obtained.

[0025] Specifically, the process of analyzing the dependency of multiple simulation tasks in the present invention is a key step in building an efficient parallel simulation system. This process includes four main stages: grouping of simulation object tasks, sorting of simulation stages, division of task stages, and determination of dependency. The system groups tasks with the same simulation object. This step utilizes the result of the previous task classification to group all tasks for the same simulation object (for example, the same CPU core or the same storage module). This grouping method is based on the assumption that there is a dependency between tasks of the same simulation object. The system sorts the tasks in each simulation object task group according to the simulation stage. Usually, tasks in the compilation stage are ranked before tasks in the simulation stage because the compilation results are usually the input of the simulation. This sorting considers more detailed stage divisions, such as preprocessing, compilation, linking, etc., to ensure the correct execution order of tasks. The sorted tasks are divided into the compilation stage and the simulation stage. The key to this step is to identify which compilation task results can be shared by multiple simulation tasks. For example, for the same simulation object, only one compilation is required, and then multiple different simulation tasks can use this compilation result. This sharing mechanism can significantly reduce duplication of work and improve overall efficiency. The system determines the specific dependencies between tasks. The main dependency is to set the shared compilation phase task as a predecessor dependency of the parallel simulation phase task. This means that all simulation tasks must wait for the compilation tasks they depend on to complete before they can start executing. A directed acyclic graph (DAG) is used to represent these dependencies, where each node represents a task and the edge represents the dependency.

[0026] In a specific embodiment, the simulation object included in the simulation task is composed of chip design code, chip environment code and library file; this embodiment also includes the following steps: Perform shell replacement processing on chip design codes to obtain multiple simulation objects; The simulation tasks of different simulation objects are processed in parallel to obtain a simulation task group executed in parallel.

[0027] In this embodiment, the simulation object of the simulation task consists of chip design code, chip environment code and library files, which reflects the complexity of the chip design and verification process. In order to further improve the simulation efficiency and coverage, the present invention introduces the empty shell replacement processing of the chip design code and the parallel processing mechanism of different simulation object tasks. The chip design code is usually the core part of the simulation task and contains the functional logic to be verified. The empty shell replacement processing is an optimization technique that creates multiple variants by replacing part of the chip design code, each variant focusing on a specific verification aspect. This process includes the following steps: Identify the modules or components that can be replaced in the chip design code. These are independent functional units. Create an "empty shell" version for each replaceable module. The empty shell version retains the interface and basic functions of the module, but the internal implementation is simplified or replaced. Generate multiple variants of the chip design code, each variant using a different empty shell replacement combination. For example, for a chip design including a CPU, a memory controller, and an I / O interface, the system creates the following variants: Variant 1: The CPU uses a detailed model and other components use an empty shell; Variant 2: The memory controller uses a detailed model and other components use an empty shell; Variant 3: The I / O interface uses a detailed model and other components use an empty shell. This embodiment allows each simulation task to focus on a specific aspect of the chip, thereby improving simulation efficiency and problem location capabilities. After creating multiple simulation objects, the system processes tasks of different simulation objects in parallel, specifically including: identifying simulation objects that are independent of each other. For example, the above three variants can be regarded as independent simulation objects. A task group is created for each independent simulation object. Each task group contains all related simulation tasks for the object. The system is configured to allow task groups of different simulation objects to execute in parallel, and appropriate task scheduling strategies and resource allocation mechanisms are set. This embodiment can run tasks of multiple simulation objects simultaneously, significantly improving overall throughput. For example, the system simultaneously runs detailed simulation of the CPU, performance analysis of the memory controller, and functional verification of the I / O interface.

[0028] In a specific embodiment, the process of executing step S3 may specifically include the following steps: According to the task dependency, the simulation tasks of different simulation objects are arranged in parallel to obtain a parallel object task group; Prioritize the compilation phase tasks in each parallel object task group to obtain a priority compilation task sequence; Arrange the simulation phase tasks in each parallel object task group in parallel to obtain a parallel simulation task sequence; Combine the priority compilation task sequence and the parallel simulation task sequence to obtain the target task list.

[0029] In this embodiment, the process of arranging multiple simulation tasks according to task dependencies to obtain a target task list is a key step in optimizing the efficiency of parallel simulation. The process includes four main stages: parallel object task group arrangement, priority compilation task sorting, parallel simulation task arrangement, and final task list generation. The system will arrange the tasks of different simulation objects in parallel according to the task dependencies obtained by the previous analysis to form parallel object task groups and identify those independent simulation object tasks that can be performed simultaneously. For example, if there are three different chip modules (such as CPU, GPU, and memory controller) that need to be simulated, the system will classify their tasks into three task groups that can be executed in parallel. This parallel arrangement will consider the following factors: Independence between simulation objects: Ensure that there is no data dependency or resource conflict between task groups executed in parallel. System resource limitations: Consider available computing resources, such as the number of CPU cores, memory capacity, etc., to ensure that the degree of parallelism does not exceed the system carrying capacity. Task priority: Assign priorities to different simulation objects according to project requirements or verification strategies. The system will prioritize the compilation phase tasks in each parallel object task group to obtain a priority compilation task sequence. This step is based on the fact that compilation is a pre-step of the simulation process, and its results are used by subsequent simulation stages. Prioritizing compilation task sorting includes: identifying all compilation tasks required for each simulation object. Analyzing the dependencies between compilation tasks, such as some modules depend on the compilation results of other modules. Creating a directed acyclic graph of compilation tasks to ensure that dependencies are satisfied. Using a topological sorting algorithm to obtain the final compilation task sequence. Arranging the simulation stage tasks in each parallel object task group in parallel to obtain a parallel simulation task sequence. The goal of this step is to maximize the parallelism of simulation tasks while ensuring correctness. Specifically, it includes: identifying independent simulation tasks that can be executed in parallel. For simulation tasks with dependencies, determining their execution order. Considering the expected execution time of simulation tasks, trying to balance the load distribution. Creating an execution plan for simulation tasks, using a method similar to the job scheduling algorithm to optimize parallelism. The system combines the priority compilation task sequence and the parallel simulation task sequence to obtain the final target task list. This combination process needs to ensure that: compilation tasks are always executed before their related simulation tasks. Maintaining the parallel characteristics of parallel object task groups. Allowing different groups of compilation and simulation tasks to be interleaved to improve resource utilization. The target task list finally generated will contain all the tasks that need to be executed, including their execution order and parallel relationship.

[0030] Among them, the process of parallel submission of simulation tasks based on cluster servers includes the following steps: receiving description information of multiple simulation tasks; converting the description information into a standardized task description format, the standardized task description format including a task identifier, a task type, resource requirements and an execution command; generating a task description file according to the standardized task description format; analyzing the task description file to identify task groups that can be executed in parallel; generating a subtask list file for each task group that can be executed in parallel; calling the batch submission interface of the cluster server to submit multiple subtask list files at the same time; monitoring the submission status of each subtask list and returning a task group identifier after the submission is completed; associating the task group identifier with the original task information to establish a task tracking mapping table; periodically querying the cluster server to obtain the execution status of each task group; according to the task tracking mapping table, converting the task group execution status into the status information of a single task; when any task status change is detected, triggering a predefined callback function to perform real-time status update.

[0031] Among them, the process of setting dynamic execution conditions of simulation tasks based on cluster servers includes the following steps: receiving a task graph containing multiple simulation tasks, wherein the task graph describes the dependency relationship between tasks; topologically sorting the task graph to generate an initial execution sequence; assigning a unique condition variable identifier to each task; creating a distributed condition variable service to manage the condition status of all tasks; expressing the execution condition of each task as a logical combination of other task condition variables; generating a task submission script, which contains query logic for the distributed condition variable service; when submitting a task to the cluster server, submitting the task submission script as a wrapper of the task; when the task starts to execute, the wrapper script first queries the distributed condition variable service to check whether the execution condition is met; if the condition is met, the actual simulation task is executed; if not, it enters a waiting state and retries periodically; after the task is executed, the condition status of itself is updated through the distributed condition variable service; periodically analyzing the task graph and condition variable status, and dynamically adjusting the task priority and resource allocation; when a potential deadlock or long waiting time is detected, the condition re-evaluation mechanism is automatically triggered, and the execution condition is relaxed if necessary.

[0032] In a specific embodiment, the process of executing step S4 may specifically include the following steps: Store multiple simulation tasks in the target task list in a file in the form of a list to obtain a task list file; Use the file submission function of the cluster server management tool to package and submit the task list files to obtain batch submitted simulation tasks; Through the task execution condition function of the cluster server management tool, set execution conditions for the simulation tasks submitted in batches to obtain simulation tasks with execution conditions; The simulation tasks with execution conditions are executed in parallel through cluster servers to obtain the task running result files.

[0033] In this embodiment, the process of delivering multiple simulation tasks on the target task list to the cluster server for execution is a key link in achieving efficient parallel simulation. The process includes four main steps: task list file generation, batch task submission, execution condition setting, and parallel task execution. The system stores multiple simulation tasks in the target task list in a list form in a file to generate a task list file. This file adopts a preset format so that the cluster server management tool can correctly parse it. The process of generating the task list file includes the following steps: Generate a unique identifier for each task. Record the key information of each task, such as task type, simulation object, execution command, input and output file paths, etc. Organize the tasks according to the previously determined execution order and parallel relationship. Write all the information into the file according to the predefined format. For example, the task list file can be in the following format: TASK_001|Compile|CPU Core|gcc -c cpu_core.c -o cpu_core.o; TASK_002|Compile|Memory Controller|gcc -c memory_controller.c -o memory_controller.o; TASK_003|Simulate|CPU Core|. / simulator cpu_core.o -t 1000; TASK_004|Simulate|Memory Controller|. / simulator memory_controller.o -t 1000. The system uses the file submission function of the cluster server management tool (such as LSF) to perform a packaging submission process on the task list file to achieve batch submission of simulation tasks. This process usually involves calling the command-line interface or API of the management tool. For example, using the bsub command of LSF: bsub < task_list_file. This batch submission method can greatly improve the efficiency of task submission and reduce system overhead. Through the task execution condition function of the cluster server management tool, set the execution conditions for the batch-submitted simulation tasks to obtain simulation tasks with execution conditions. The purpose of this step is to ensure that the tasks are executed in the correct order and optimize resource utilization. Setting the execution conditions includes the following aspects: Dependency condition: Specify that a certain task must start after another task has been successfully completed. This is usually used to handle the relationship between compilation tasks and corresponding simulation tasks. For example: bsub -w "done(TASK_001)" . / run_simulation TASK_003; Resource condition: Specify the computing resources required for task execution, such as the number of CPU cores, memory size, etc. For example: bsub -n 4 -R "rusage[mem=8192]" . / run_simulation TASK_003; Time condition: Set the maximum running time of the task, and it will automatically terminate after timeout.For example: bsub -W 120 . / run_simulationTASK_003; Parallelism condition: Control the number of tasks running at the same time to avoid system overload. For example: Use job arrays and limit the number of tasks running at the same time: bsub -J "sim[1-100]%10" . / run_simulation. Through these condition settings, the system can more finely control the execution process of tasks, which not only ensures the correctness of tasks, but also improves resource utilization efficiency. The system executes simulation tasks with execution conditions in parallel through cluster servers to obtain task running result files. At this stage, the cluster server management tool will automatically schedule and execute tasks according to the previously set conditions. During the execution process, the system will: Monitor the running status of tasks, including start time, running progress, resource usage, etc. Dynamically adjust the execution order and parallelism of tasks according to the dependencies and execution conditions of tasks. Handle abnormal situations that occur during task execution, such as task failure, insufficient resources, etc. Collect the output results of each task, including standard output, error logs, performance data, etc. After the task is completed, the system will integrate all related output and log files to form a complete set of task operation result files.

[0034] In a specific embodiment, the process of executing step S5 may specifically include the following steps: Parse the task running result file to obtain the execution status information of each simulation task; Based on the execution status information, the success, failure and invalidity of the simulation task are counted to obtain the task execution statistics; Analyze the statistical results of task execution and calculate the regression pass rate; Collect the start time, end time and running time information of the simulation task to obtain task time statistics; Generate a regression test report based on task execution statistics, regression pass rate and task time statistics.

[0035] In this embodiment, the process of statistically analyzing the task running result file to generate a regression test report is a key step in evaluating the effect of the entire simulation process. The process includes five main stages: result file parsing, task execution statistics, regression pass rate calculation, time information collection and report generation. The system will parse the task running result file to obtain the execution status information of each simulation task. This parsing process involves the following steps: identifying and reading the output file of each task, including log files, result files, etc. Using predefined patterns or rules to parse the file content and extract key information. For each task, determine its final state (success, failure, invalid, etc.). Extract important information during the task execution process, such as error messages, warnings, performance indicators, etc. For example, the system looks for specific success or failure signs, such as "Simulation completed successfully" or "Error: assertion failed". Based on the execution status information obtained by parsing, the system will count the success, failure and invalidity of the simulation task to obtain the task execution statistics. This statistical process includes: calculating the total number of tasks, the number of successful tasks, the number of failed tasks and the number of invalid tasks. Classify failed tasks, such as compilation errors, simulation errors, and failures caused by insufficient resources. Analyze the reasons for invalid tasks, such as missing input data, environment configuration problems, etc. Generate distribution charts of various task states, such as pie charts or bar charts. The third step is to analyze the statistical results of task execution and calculate the regression pass rate. The regression pass rate is usually defined as the ratio of the number of successfully completed tasks to the total number of valid tasks. The calculation process includes: determining the total number of valid tasks (total number of tasks minus the number of invalid tasks). Calculating the percentage of successful tasks to the total number of valid tasks. The individual pass rates of different types of tasks (such as compilation tasks and simulation tasks) are also calculated. Compare the calculated results with the preset target pass rate to determine whether this regression test meets the standard. The system collects the start time, end time and running time information of the simulation task to obtain task time statistics. This process involves: extracting the specific start and end timestamps of each task from the task log. Calculating the actual running time of each task. Counting the total running time of the entire regression test. Analyzing the distribution of task running time, such as average running time, maximum running time, minimum running time, etc. Generate a distribution chart of task running time, such as a histogram or box plot. The system will generate a comprehensive regression test report based on the task execution statistics, regression pass rate and task time statistics. This report usually includes but is not limited to the following:Executive Summary: Including key indicators such as the total number of tasks, the number of successful / failed / invalid tasks, and the regression pass rate. Detailed Statistics: The specific number and percentage of each type of task, including chart display. Time Analysis: Total running time, average task time, time distribution and other information. Failed Task Analysis: Lists failed tasks, including failure reasons and related log summaries.Performance indicators: If applicable, performance data such as simulation speed, resource utilization, etc. Comparative analysis: Compare with previous regression test results to show trends.

[0036] Further, the historical running data of the multiple simulation tasks are subjected to machine learning analysis to obtain a task running time prediction model: first, the detailed running data of all simulation tasks in the past at least 6 months are collected and sorted, including but not limited to task type, simulation object, code complexity, input data scale, computing resources used, start time, end time, running time and other information. These data are stored in a dedicated data warehouse, and data cleaning and standardization are performed. Then, a variety of machine learning algorithms, such as random forest, gradient boosting tree, deep neural network, etc., are used to model the processed data. In the modeling process, cross-validation technology is used to evaluate the model performance, and grid search or Bayesian optimization methods are used to adjust the model hyperparameters. Finally, the model with the best performance on the validation set is selected as the final task running time prediction model. In addition, a regular automated process is established to update the model with the latest running data every week to ensure that the model can adapt to the dynamic changes of the system. Using the task running time prediction model, the running time of each simulation task in the target task list is predicted: for each simulation task in the target task list, feature information consistent with the prediction model input is extracted, including task type, simulation object, code complexity estimate, expected input data scale, etc. Input these feature information into the prediction model obtained in step 8.1 to obtain the predicted running time. Considering the uncertainty of the prediction, in addition to obtaining the point estimate, the confidence interval of the prediction is also calculated, usually using a 95% confidence interval. In order to improve the robustness of the prediction, an ensemble learning method can be used, such as using different machine learning models for prediction, and then obtaining the final prediction result by weighted average or voting. In addition, the results of each prediction and the actual running time are recorded for subsequent model evaluation and improvement. According to the predicted running time, the target task list is dynamically optimized and sorted to obtain an optimized target task list: First, a priority score is calculated for each task based on the predicted running time and confidence interval. This score not only considers the predicted running time, but also the importance, urgency, resource requirements and other factors of the task. For example, a weighted sum method can be used: score = w1 * normalized running time + w2 * task importance + w3 * urgency - w4 * resource requirements, where w1, w2, w3, w4 are weight coefficients that can be determined by historical data analysis or expert experience. Then, use an efficient sorting algorithm (such as quick sort or heap sort) to sort the tasks and get a preliminary sorting result. Next, consider the dependencies between tasks and use a topological sorting algorithm to adjust the preliminary sorting result to ensure that the execution order of dependent tasks is correct. Finally, implement a dynamic adjustment mechanism. During the task execution process, if the completion time of some tasks deviates seriously from the expected time, the reordering process is automatically triggered to adapt to the changes in the real-time situation.Deliver the optimized target task list to the cluster server to improve cluster resource utilization and overall task execution efficiency: Develop an intelligent task scheduler that can understand the optimized target task list and is tightly integrated with the cluster resource management system. The scheduler first analyzes the current resource usage of the cluster, including the usage of CPU, memory, storage, and network bandwidth. Then, the optimal resource allocation strategy is formulated based on the predicted running time and resource requirements of each task. In the allocation process, a variant of the bin-packing algorithm is adopted, and tasks are regarded as "items" of different sizes, and cluster nodes are regarded as "containers", so that tasks are allocated to each node as compactly as possible. At the same time, a task preheating mechanism is implemented to prepare the necessary environment and data for the tasks to be executed in advance, thereby reducing the task startup time. In addition, a real-time monitoring system is established to continuously track the execution progress and resource usage of each task. When it is detected that the load of a node is too high or too low, the task migration process is automatically triggered to reallocate the task to a more suitable node to balance the cluster load. Finally, an intelligent caching strategy is implemented to cache frequently used data or intermediate results in memory or fast storage to reduce repeated calculations and data transmission, further improving execution efficiency.

[0037] Set multiple key performance indicator (KPI) thresholds to evaluate the performance of simulation tasks: First, determine a comprehensive and representative set of key performance indicators (KPIs) by analyzing historical simulation task data and consulting domain experts. These KPIs should cover multiple aspects, including but not limited to: computational efficiency (such as the number of simulation steps completed per second), memory usage, I / O throughput, network bandwidth utilization, simulation accuracy (such as deviation from actual hardware behavior), convergence speed (for iterative algorithms), etc. For each KPI, establish a dynamic threshold setting mechanism. The initial threshold can be set based on statistical analysis of historical data, such as using the upper or lower limit of a 95% confidence interval. Then, implement an adaptive threshold adjustment algorithm that can automatically fine-tune the threshold based on the task execution status over a recent period of time (such as the past 30 days). This approach can adapt to long-term changes in system performance. In addition, set differentiated thresholds for different types of simulation tasks, as different types of tasks may have different performance characteristics and requirements. Finally, establish a visual KPI dashboard that allows administrators to intuitively monitor and manually adjust these thresholds. Monitor the performance indicators of the tasks in real time during the execution of the simulation tasks: Develop a distributed real-time monitoring system that can collect detailed performance data for each simulation task in a way that minimizes performance overhead. Deploy lightweight monitoring agents on each cluster node. These agents are responsible for collecting performance indicators of local tasks, including system-level indicators such as CPU usage, memory consumption, disk I / O, network traffic, and simulation-specific indicators such as simulation progress and convergence. Use efficient data compression and transmission protocols (such as Protocol Buffers or Apache Avro) to transmit the collected data to the central monitoring server in real time. On the central server, implement a stream processing engine (such as Apache Flink or Kafka Streams) to aggregate and analyze the incoming performance data in real time. Use sliding window technology to calculate statistics such as moving averages and standard deviations of various indicators to reduce the impact of instantaneous fluctuations. At the same time, implement anomaly detection algorithms, such as statistical-based methods (such as Z-score) or machine learning models (such as Isolation Forest) to quickly identify performance anomalies. In addition, a real-time alarm system is established to promptly notify relevant personnel through multiple channels (such as email, SMS, and instant messaging tools) when performance indicators are detected to be close to or exceed preset thresholds. When a performance indicator of a simulation task is detected to exceed a preset threshold, a task interruption mechanism is automatically triggered: an intelligent task interruption controller is implemented, which is tightly integrated with the real-time monitoring system. When a performance anomaly alert is received, the controller first evaluates the severity and duration of the anomaly. For minor or short-term anomalies, early warning measures may be taken, such as increasing the monitoring frequency or adjusting resource allocation. If the anomaly persists or reaches a critical level, a progressive interruption process is initiated.First, try to terminate the task gracefully by sending a soft interrupt signal (such as SIGTERM), giving the task a certain amount of time to clean up and save intermediate results. If the soft interrupt fails to terminate the task within the scheduled time, it is upgraded to a hard interrupt (such as SIGKILL) to force the task process to end. During the interruption process, the cause, time, and related performance indicators of the interruption are recorded in detail for subsequent analysis. At the same time, a task state preservation mechanism is implemented to save the key state and intermediate results of the task to persistent storage before the interruption for subsequent recovery or analysis. In addition, a task dependency graph is established, and when a task is interrupted, the affected downstream tasks are automatically evaluated and processed, such as pausing or rescheduling these tasks. Fault analysis of interrupted tasks and generation of optimization recommendation reports: Develop an automated fault analysis system that can deeply analyze the causes of task interruptions. First, collect all data related to the interrupted task, including task configuration, input data characteristics, execution environment information, detailed performance logs, system logs, etc. Use natural language processing technology to analyze the logs and extract key events and error information. Then, apply root cause analysis algorithms, such as fault tree analysis (FTA) or Bayesian networks, to infer possible causes of the fault. At the same time, machine learning techniques, such as decision trees or random forests, are used to learn from historical fault data to improve the accuracy of root cause analysis. Based on the analysis results, detailed fault reports are automatically generated, including fault description, impact scope, possible causes, recommended solutions, etc. In addition, knowledge graph technology is implemented to associate newly discovered fault modes with known problem libraries, which helps to identify systemic problems and long-term trends. Finally, natural language generation (NLG) technology is used to convert technical analysis results into easy-to-understand optimization recommendation reports, and the report content and format are customized according to different audiences (such as developers and managers). According to the optimization recommendation report, relevant simulation parameters or configurations are automatically adjusted, and the optimized simulation task is resubmitted: Implement an intelligent configuration management system that can parse the optimization recommendation report and automatically generate corresponding configuration adjustment strategies. First, use natural language processing technology to extract specific optimization recommendations from the report. Then, map these recommendations to actionable configuration parameters or system settings. Develop a rule engine to generate specific parameter adjustment plans for each optimization recommendation based on predefined strategies and historical experience. For example, if the report recommends increasing memory allocation, the system automatically calculates the appropriate new memory settings based on current usage and available resources. Implement a configuration version control system to record detailed information about each adjustment, including the reason for the adjustment, specific changes, and expected effects, for subsequent tracking and rollback. Before applying a new configuration, use configuration validation tools to check whether the adjusted parameters meet system constraints and best practices. If potential problems are found, the system will generate warnings and recommend manual intervention.Once the new configuration is verified, the optimized simulation task is automatically created, including updating the task description file, repackaging the necessary resources, etc. Finally, the optimized task is resubmitted to the task queue and marked as high priority so that the optimization effect can be verified as soon as possible. At the same time, a feedback loop mechanism is established to closely monitor the performance of the resubmitted tasks and feed the results back to the analysis system to continuously improve the optimization strategy. Build a distributed cache system to store intermediate results and frequently accessed data of simulation tasks: Design and implement a high-performance, scalable distributed cache system that can effectively manage and store intermediate results and frequently accessed data of simulation tasks. First, select a suitable distributed cache technology, such as Redis, Memcached, or a custom distributed hash table implementation. Considering the particularity of simulation data, it may be necessary to support large-capacity object storage and complex data structures. Implement a multi-level cache architecture, including memory cache, SSD cache, and distributed file system cache to balance performance and capacity requirements. Design intelligent data sharding and replication strategies to ensure that data is evenly distributed across cluster nodes and provide sufficient redundancy to prevent node failures. Implement a consistent hashing algorithm to minimize the amount of data that needs to be redistributed when adding or removing nodes. Develop efficient serialization and deserialization mechanisms to optimize data storage and transmission efficiency. For example, you can use binary serialization formats such as Protocol Buffers or Apache Avro. Implement data compression functions and select appropriate compression algorithms based on the data type, such as LZ4 for fast compression / decompression, or ZSTD for high compression ratio scenarios. Design cache eviction strategies, combining mechanisms such as LRU (least recently used), LFU (least frequently used), and TTL (time to live) to adapt to the access patterns of different types of data. Implement a cache warm-up mechanism to preload the data that may be needed based on historical access patterns before the simulation task starts. Finally, develop comprehensive monitoring and management tools, including real-time statistics, performance analysis, capacity planning, and other functions to ensure the efficient operation of the cache system. Before executing the simulation task, check whether there are reusable intermediate results in the distributed cache system: Develop an intelligent cache query system that can efficiently retrieve reusable intermediate results before the simulation task is executed. First, generate a unique identifier for each simulation task and intermediate result. This identifier should contain a hash value of key information such as task type, input parameters, and simulation environment version. Implement multidimensional index structures, such as B-trees or LSM-trees, to support efficient multi-condition queries. Design fuzzy matching algorithms that allow finding the most similar cached results when an exact match is not available. For example, locality sensitive hashing (LSH) techniques can be used to quickly find similar simulation configurations. Implement parallel query mechanisms to search on multiple cache nodes simultaneously to reduce query latency. Develop a cache result validation system to ensure that the retrieved cached data is still valid and compatible with the current simulation environment.This may involve checking data versions, verifying data integrity, evaluating data freshness, etc. Implement intelligent pre-fetching strategies to load cached data that may be needed into faster storage layers (e.g., pre-loading from disk to memory) in advance based on task dependency graphs and historical access patterns. Finally, establish a cache hit rate analysis system to continuously monitor and analyze cache usage to provide a basis for subsequent cache optimization. If there are reusable intermediate results, use the cached data directly and skip the corresponding calculation steps: Implement a plug-in for an intelligent task scheduler that can dynamically adjust the execution plan of simulation tasks based on cache query results. First, develop a task decomposer to split complex simulation tasks into a series of subtasks or calculation steps. Build an input-output dependency graph for each subtask to identify steps that can be replaced by cached results. Design a cache data integration mechanism to ensure that cached data can be seamlessly inserted into the simulation process. This may involve operations such as data format conversion, coordinate system adjustment, or unit conversion. Implement an incremental calculation framework that allows the simulation to continue from the nearest available cache point instead of completely skipping subsequent steps. Develop an intelligent judgment system to evaluate the cost-effectiveness of using cached data and recomputation, considering factors such as data loading time, computational complexity, and result accuracy requirements. Implement a parallel preprocessing mechanism to perform other necessary initialization or preparation work in parallel while using cached data to maximize performance improvement. Design a rollback mechanism to quickly switch back to full computation mode when anomalies or inconsistencies caused by cached data are detected. Finally, establish a detailed logging system to track the use of cache in each simulation task, including saved computation time, resource utilization changes, etc., to provide a basis for further optimization. Store newly generated intermediate results in a distributed cache system during simulation task execution: Develop a real-time cache writing system that can efficiently store newly generated intermediate results in a distributed cache during simulation task execution. First, implement an intelligent checkpoint mechanism to automatically determine appropriate cache points based on task complexity, running time, and resource consumption. At these points, the system triggers the capture and storage of intermediate results. Design an asynchronous write mechanism to ensure that cache operations do not significantly affect the performance of the main simulation process. You can use a producer-consumer pattern to offload cache write operations to dedicated background threads or processes. Implement an incremental update strategy to store only the data that has changed since the last checkpoint to reduce storage and network overhead. Develop a data preprocessing pipeline to perform necessary processing on intermediate results before storage, such as denoising, compression, format conversion, etc. Implement an intelligent sharding strategy to split and distribute large intermediate results according to the characteristics and access patterns of the data to improve subsequent reading efficiency. Design a metadata management system to maintain rich meta-information for each cached intermediate result, including generation time, related simulation parameters, data dependencies, etc. Implement a version control mechanism to allow storage of multiple versions of the same intermediate result to support rollback and comparative analysis.Finally, develop a cache consistency protocol to ensure that all nodes in a distributed environment can access the latest and consistent cache data. Regularly analyze cache usage and automatically adjust cache policies to optimize cache hit rate and storage space utilization: Implement an adaptive cache optimization system that can continuously monitor, analyze, and optimize the performance of distributed caches. First, develop a comprehensive cache usage monitoring mechanism to collect detailed access logs, including access frequency, last access time, data size, life cycle, and other information for each cache item. Implement a real-time analysis engine to continuously analyze cache access patterns using stream processing technologies such as Apache Flink or Kafka Streams. Apply machine learning algorithms such as time series analysis and clustering algorithms to identify periodic patterns and hot data in data access. Based on the analysis results, dynamically adjust the cache policy, including adjusting cache capacity allocation, modifying data expiration policies, and optimizing data distribution. For example, an automatic expansion mechanism can be implemented to automatically increase cache nodes when a sustained high load is detected. Develop an intelligent prefetching algorithm to predict and load the data that may be needed in advance based on the identified access patterns. Implement advanced cache replacement strategies, such as ARC (Adaptive Replacement Cache) or LIRS (Low Inter-reference Recency Set), to better adapt to different access patterns. Design a storage tiering mechanism to automatically migrate data between storage media with different performance and costs based on the access frequency and importance of the data. Implement a cache defragmentation mechanism to regularly organize the storage space and improve space utilization. Finally, establish a comprehensive performance reporting system to generate detailed cache usage analysis reports, including hit rate trends, storage efficiency, optimization suggestions, etc., to provide decision support for administrators.

[0038] Among them, the method also includes: before executing the multiple simulation tasks, real-time monitoring of the resource status of the cluster server to obtain resource utilization data; dynamically optimizing and scheduling the target task list based on the resource utilization data, including: when idle resources are detected, scheduling the simulation tasks with higher priorities in advance; when resource shortages are detected, delaying the scheduling of simulation tasks on non-critical paths; updating the target task list based on the dynamic optimization scheduling results to obtain an optimized target task list; and delivering multiple simulation tasks on the optimized target task list to the cluster server for execution.The real-time monitoring of the resource status of the cluster servers to obtain resource utilization data includes: setting a resource monitoring interval to regularly sample the CPU utilization, memory utilization, storage space utilization and network bandwidth utilization of the cluster servers; storing the sampled resource utilization data in a time series database to form a resource utilization history record; based on the resource utilization history record, calculating the average utilization, peak utilization and fluctuation range of each resource in different time periods to obtain resource utilization statistics; according to a preset resource utilization threshold, analyzing the resource utilization statistics to identify resource bottlenecks and idle resources to obtain a resource status evaluation result; according to the resource utilization data, dynamically optimizing and scheduling the target task list, also includes: based on the resource status evaluation result, constructing a resource optimization strategy library, including a high CPU utilization strategy, a high memory utilization strategy, a high storage utilization strategy and a high bandwidth utilization strategy; performing resource demand analysis on each simulation task in the target task list to obtain task resource demand characteristics; according to the task resource demand characteristics and the current resource status, selecting a matching optimization strategy from the resource optimization strategy library; based on the selected optimization strategy, Priority adjustment and execution time window allocation for real tasks; the scheduling of high-priority simulation tasks in advance includes: identifying critical path tasks and high-priority tasks in the target task list; when available resources are detected, inserting the critical path tasks and high-priority tasks into the front end of the current execution queue; reserving sufficient resource quotas for the tasks scheduled in advance to ensure that they can be quickly started and executed; the scheduling of simulation tasks on non-critical paths after delay includes: identifying non-critical path tasks and low-priority tasks in the target task list; when resource shortage is detected, removing the non-critical path tasks and low-priority tasks from the current execution queue; setting waiting conditions for delayed tasks to automatically trigger rescheduling when resource status improves; the method also includes: real-time monitoring of resource usage of the simulation tasks being executed, and performing task intervention processing when abnormal resource usage of the tasks is detected; the task intervention processing includes task suspension, resource limit adjustment, task priority reduction and task forced termination; recording the execution process and results of the dynamic optimization scheduling, and generating a scheduling optimization log; based on the scheduling optimization log, evaluating and providing feedback on the effectiveness of the optimization strategy, and continuously optimizing the resource scheduling algorithm.The method also includes: performing machine learning analysis on the historical execution data of the multiple simulation tasks to obtain a task execution time prediction model; using the task execution time prediction model to predict the execution time of each simulation task in the target task list to obtain a predicted execution time; grouping tasks and optimizing the parallelism of the target task list based on the predicted execution time, including: assigning tasks with similar predicted execution times to the same group; determining the parallelism of each task group based on the overall predicted execution time of the task group; generating an optimized target task list based on the task grouping and parallelism optimization results; and delivering multiple simulation tasks on the optimized target task list to a cluster server for execution.The method of performing machine learning analysis on the historical execution data of the multiple simulation tasks to obtain a task execution time prediction model includes: collecting historical execution data of simulation tasks, including task type, simulation object, simulation stage, input parameters, resource configuration and actual execution time; preprocessing the collected historical data, including data cleaning, feature extraction and data standardization; dividing the preprocessed data set into a training set and a test set; selecting a suitable machine learning algorithm, such as a random forest, a gradient boosting tree or a neural network, to build a task execution time prediction model; training the model using the training set, and evaluating the model performance using the test set; optimizing the model performance through cross-validation and hyperparameter tuning; deploying the trained model to a production environment for real-time prediction of task execution time; using the task execution time prediction model to predict the execution time of each simulation task in the target task list to obtain a predicted execution time, including: extracting features of each simulation task, including task type, simulation object, simulation stage and input parameters; inputting the extracted features into the task execution time prediction model to obtain a predicted execution time; calculating the predicted execution time. The confidence interval of the time is used to evaluate the reliability of the prediction result; the predicted execution time and its confidence interval are added to the task attributes; the target task list is grouped and the parallelism is optimized according to the predicted execution time, and it also includes: setting an execution time similarity threshold to divide the tasks whose predicted execution time difference is less than the threshold into the same group; calculating the overall predicted execution time and resource requirements of each task group; allocating appropriate parallelism to each task group based on the overall resource capacity of the cluster server; within the task group, determining the fine-grained execution order according to the dependency and priority of the tasks; the method also includes: comparing the actual execution time of the task with the predicted execution time in real time during the task execution process; triggering the online update of the prediction model when there is a significant deviation between the actual execution time and the predicted time; collecting new task execution data and regularly retraining the prediction model offline to adapt to changes in the simulation environment; evaluating the prediction accuracy of the model based on the performance indicators of the prediction model, such as root mean square error and mean absolute percentage error; and automatically triggering the model structure optimization or feature engineering process when the prediction accuracy drops below a preset threshold.

[0039] The regression test report in this embodiment provides the project team with a comprehensive overview of the regression test results, which helps to quickly evaluate the status of the current chip design, find potential problems, and provide guidance for subsequent development and verification work. Through this systematic analysis and report generation process, the present invention not only improves the simulation efficiency, but also greatly enhances the interpretability and operability of the results, thereby accelerating the entire chip development cycle.

[0040] The above describes the parallel simulation regression method based on the cluster server in the embodiment of the present invention. The following describes the parallel simulation regression system based on the cluster server in the embodiment of the present invention. Figure 2 In one embodiment of the present invention, a parallel simulation regression system based on a cluster server includes: A classification module is used to classify multiple simulation tasks and obtain the task type of each simulation task; An analysis module is used to analyze the dependency of multiple simulation tasks according to the task type to obtain the task dependency; An arrangement module is used to arrange multiple simulation tasks according to task dependencies to obtain a target task list; The running module is used to deliver multiple simulation tasks on the target task list to the cluster server, and run the multiple simulation tasks through the cluster server to obtain the task running result file; The statistics module is used to perform statistical analysis on the task running result files and obtain the regression test report.

[0041] Through the collaborative cooperation of the above-mentioned components, the parallel simulation regression system of the present invention can efficiently utilize the parallelism and dependency of regression simulation tasks, maximize the parallel operation of simulation tasks, greatly improve regression efficiency, and accelerate verification iterations. At the same time, using the built-in functions of the cluster server management tool, a regression simulation task list can be easily generated and submitted, avoiding complex process script tool development and debugging, and greatly reducing the difficulty of system development. The system can be applied to common simulation tools and cluster server management tools, and has versatility.

[0042] The present invention also provides a computer device, which includes a memory and a processor, wherein the memory stores computer-readable instructions, and when the computer-readable instructions are executed by the processor, the processor executes the steps of the cluster server-based parallel simulation regression method in the above-mentioned embodiments.

[0043] The present invention also provides a computer-readable storage medium, which may be a non-volatile computer-readable storage medium or a volatile computer-readable storage medium. Instructions are stored in the computer-readable storage medium. When the instructions are executed on a computer, the computer executes the steps of the cluster server-based parallel simulation regression method.

[0044] Those skilled in the art can clearly understand that, for the convenience and brevity of description, the specific working processes of the above-described systems, systems and units can refer to the corresponding processes in the aforementioned method embodiments and will not be repeated here.

[0045] If the integrated unit is implemented in the form of a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present invention is essentially or the part that contributes to the prior art or the whole or part of the technical solution can be embodied in the form of a software product. The computer software product is stored in a storage medium, including several instructions to enable a computer device (which can be a personal computer, server, or network device, etc.) to perform all or part of the steps of the method described in each embodiment of the present invention. The aforementioned storage medium includes: U disk, mobile hard disk, read-only memory (ROM), random access memory (RAM), disk or optical disk and other media that can store program code.

[0046] As described above, the above embodiments are only used to illustrate the technical solutions of the present invention, rather than to limit the same. Although the present invention has been described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that the technical solutions described in the aforementioned embodiments may still be modified, or some of the technical features thereof may be replaced by equivalents. However, these modifications or replacements do not deviate the essence of the corresponding technical solutions from the spirit and scope of the technical solutions of the embodiments of the present invention.

Claims

1. A parallel simulation regression method based on cluster servers, characterized in that: The method comprises: Classify multiple simulation tasks to obtain the task type of each simulation task; According to the task type, performing dependency analysis on the multiple simulation tasks to obtain task dependency; Arrange the plurality of simulation tasks according to the task dependency relationship to obtain a target task list; Delivering multiple simulation tasks on the target task list to a cluster server, and running the multiple simulation tasks through the cluster server to obtain a task running result file; Perform statistical analysis on the task running result file to obtain a regression test report.

2. The parallel simulation regression method based on cluster servers according to claim 1, characterized in that: The multiple simulation tasks are classified to obtain the task type of each simulation task, including: Performing simulation object identification on multiple simulation tasks to obtain a simulation object of each simulation task; Performing simulation stage judgment on the multiple simulation tasks to obtain a simulation stage of each simulation task; The multiple simulation tasks are classified according to the simulation object and the simulation stage to obtain a task type of each simulation task.

3. The parallel simulation regression method based on cluster servers according to claim 2 is characterized in that: The step of performing dependency analysis on the plurality of simulation tasks according to the task types to obtain task dependency relationships includes: Grouping the multiple simulation tasks with the same simulation object to obtain a simulation object task group; Sorting the simulation tasks in each of the simulation object task groups according to the simulation stage to obtain an ordered simulation task group; Dividing the simulation tasks in the ordered simulation task group into a compilation phase and a simulation phase to obtain a task set of a shared compilation phase and a parallel simulation phase; The simulation task in the shared compilation phase is determined as a pre-dependency of the task in the parallel simulation phase to obtain a task dependency relationship.

4. The cluster server-based parallel simulation regression method according to claim 3, characterized in that: The simulation object included in the simulation task consists of chip design code, chip environment code and library file; the method also includes: Performing shell replacement processing on the chip design code to obtain multiple simulation objects; The simulation tasks of different simulation objects are processed in parallel to obtain a simulation task group executed in parallel.

5. The parallel simulation regression method based on cluster servers according to claim 1, characterized in that: The step of arranging the plurality of simulation tasks according to the task dependency relationship to obtain a target task list includes: Arranging the simulation tasks of different simulation objects in parallel according to the task dependency relationship to obtain a parallel object task group; Prioritize the compilation phase tasks in each parallel object task group to obtain a priority compilation task sequence; Arrange the simulation phase tasks in each parallel object task group in parallel to obtain a parallel simulation task sequence; The priority compilation task sequence and the parallel simulation task sequence are combined to obtain a target task list.

6. The parallel simulation regression method based on cluster servers according to claim 1, characterized in that: The step of delivering the multiple simulation tasks on the target task list to a cluster server, and running the multiple simulation tasks through the cluster server to obtain a task running result file includes: The plurality of simulation tasks in the target task list are stored in a file in a list form to obtain a task list file; Using the file submission function of the cluster server management tool, the task list file is packaged and submitted to obtain simulation tasks submitted in batches; By using the task execution condition function of the cluster server management tool, setting execution conditions for the simulation tasks submitted in batches to obtain simulation tasks with execution conditions; The simulation tasks with execution conditions are executed in parallel by the cluster servers to obtain task running result files.

7. The cluster server-based parallel simulation regression method according to claim 1, characterized in that: The statistical analysis of the task running result file is performed to obtain a regression test report, including: Parsing the task running result file to obtain the execution status information of each simulation task; Based on the execution status information, statistics are collected on the success, failure and invalidity of the simulation task to obtain task execution statistics results; Analyze the statistical results of the task execution and calculate the regression pass rate; Collect the start time, end time and running time information of the simulation task to obtain task time statistics; A regression test report is generated according to the task execution statistical results, the regression pass rate and the task time statistical data.

8. A parallel simulation regression system based on cluster servers, characterized in that: Used to execute the cluster server-based parallel simulation regression method according to any one of claims 1 to 7, the system comprises: A classification module is used to classify multiple simulation tasks and obtain the task type of each simulation task; An analysis module, used for performing dependency analysis on the plurality of simulation tasks according to the task types to obtain task dependency relationships; An arrangement module, used for arranging the plurality of simulation tasks according to the task dependency relationship to obtain a target task list; An operation module is used to deliver the multiple simulation tasks on the target task list to the cluster server, and run the multiple simulation tasks through the cluster server to obtain a task running result file; The statistical module is used to perform statistical analysis on the task running result file to obtain a regression test report.

9. A computer device, characterized in that: It comprises a memory and a processor, wherein the memory stores a computer program that can be run on the processor, and is characterized in that when the processor executes the computer program, the parallel simulation regression method based on a cluster server described in any one of claims 1 to 7 is implemented.

10. A computer-readable storage medium having a computer program stored thereon, wherein when the computer program is executed by a processor, the processor is enabled to execute the cluster server-based parallel simulation regression method according to any one of claims 1 to 7.

Citation Information

Cited By

  • Business process regulation and control system and method, electronic equipment and storage medium

    CN119377077A

  • Parallel simulation regression method and system based on cluster server

    CN119514434A

  • Shell script task scheduling method and system in network-free state

    CN119576504A

  • FPGA channel simulation-oriented cluster dynamic scheduling method and system and medium

    CN119629674A

  • A cluster dynamic scheduling method, system and medium for FPGA channel simulation

    CN119629674B