Automatic test analysis method and system for intelligent cockpit large model

Abstract

The invention discloses an automatic test analysis method and system for an intelligent cockpit large model, and relates to the technical field of test analysis, when a thread pool adjustment mechanism is triggered, resource data of a thread pool in a test process of a test case is obtained, and the state uncertainty of the thread pool is calculated; obtaining all test task relationship dependency data corresponding to the test case to calculate a task dependency degree; according to the state uncertainty of the thread pool and the task dependency degree, calculating a non-regulation degree; and judging whether to adjust the thread pool according to the non-regulation degree to adjust the state of the thread pool in the automatic test of the intelligent cockpit large model. According to actual judgment, in the automatic testing process of the intelligent cockpit large model, when a thread pool adjusting mechanism is triggered, whether the state of the thread pool needs to be adjusted truly or not can be judged, unnecessary frequent adjustment is avoided, the phenomena of waste of system resources and reduction of execution efficiency are reduced, the stability of the system is ensured, testing tasks are scheduled in order, and the testing efficiency is improved. The stability of the test process is ensured.

Description

Technical Field

[0001] This invention relates to the field of testing and analysis technology, specifically to an automated testing and analysis method and system for a large-scale intelligent cockpit model. Background Technology

[0002] With the continuous development of intelligent cockpit technology, modern automotive cockpit systems not only need to possess traditional in-vehicle entertainment and navigation functions, but also need to support complex functions such as voice recognition, artificial intelligence assistants, and driving behavior analysis. To ensure the stability and efficiency of these systems in actual use, comprehensive automated testing is required. Intelligent cockpit large-scale automated testing platforms have emerged to address this need. By constructing an efficient automated testing framework, these platforms simulate various user behaviors and environmental changes to test the responsiveness and performance of the cockpit system. In automated testing platforms, test case execution is typically improved by processing multiple tasks in parallel to ensure that tests are completed in the shortest possible time. This requires the system to rationally allocate resources to meet the computational demands of parallel task execution. During the scheduling of parallel tasks, thread pools, as an efficient resource management mechanism, are widely used in task scheduling and management.

[0003] Thread pools maintain a certain number of threads, avoiding the creation of independent threads for each task, thereby reducing resource consumption and improving task execution efficiency. For example, in the automated testing of a large-scale intelligent cockpit model, the system may need to execute multiple test cases simultaneously, such as testing speech recognition, navigation, and driving behavior analysis. Suppose the system allocates a thread pool containing 10 threads to execute these tasks. If a test case is relatively simple, some threads in the pool will remain idle. However, if another test case has a higher computational load, the thread pool can dynamically adjust the number of threads based on the actual task load. For instance, if the system finds that the speech recognition test case takes a long time to execute, the thread pool may expand to 15 threads to accelerate the parallel execution of other tasks. Conversely, when the task is lighter, the number of threads in the pool may be reduced to 8 to avoid wasting resources. This dynamic adjustment mechanism ensures that the testing platform can operate efficiently under different loads, making full use of system resources.

[0004] However, frequently adjusting the thread pool size in automated testing can lead to a series of problems. When task load changes, the system may expand or shrink the thread pool based on real-time task execution, but excessively frequent adjustments can result in context switching overhead, impacting execution efficiency and system stability. For example, suppose that during automated testing of a large-scale intelligent cockpit model, the system triggers a thread pool adjustment mechanism. The system will determine in real-time whether to expand or shrink the thread pool based on factors such as task execution time and system load. Dynamically adjusting the thread pool size can effectively utilize system resources and improve the efficiency of parallel task execution. However, frequent expansion and contraction of the thread pool can cause performance issues. Each adjustment to the thread pool size involves thread creation and destruction, triggering context switching, which in turn leads to wasted system resources and decreased execution efficiency. Furthermore, frequent thread pool adjustments can also cause system instability, especially when there are strong dependencies between tasks or long execution chains. Excessive thread pool adjustments can disrupt task scheduling, thus affecting the stability of the testing process.

[0005] Therefore, in the automated testing of large-scale intelligent cockpit models, the core issue that needs to be addressed is how to intelligently determine whether the thread pool truly needs adjustment, rather than blindly expanding or shrinking it. Summary of the Invention

[0006] The purpose of this invention is to solve the problems mentioned above and to provide an automated testing and analysis method and system for large-scale intelligent cockpit models.

[0007] In a first aspect of this invention, an automated testing and analysis method for a large-scale intelligent cockpit model is first proposed, the method comprising: When the thread pool adjustment mechanism is triggered, the resource data of the thread pool during the test case is obtained, and the uncertainty of the thread pool state is calculated based on the resource data. Obtain all test task dependency data corresponding to the test cases, and calculate the task dependency degree based on the task dependency data; Calculate the degree of no regulation required based on the uncertainty of the thread pool state and the task dependency; The thread pool state in the automated testing of the large-scale intelligent cockpit model is adjusted based on whether the thread pool needs to be adjusted without requiring control.

[0008] Optionally, the steps for calculating the uncertainty of the thread pool state based on resource data are as follows: Get the activity status of each thread in the thread pool at each time point. When a thread is executing a task at a given time point, its activity status value is 1. Thread If the current thread is in an idle state, the activity state value is 0; and a thread activity matrix is ​​constructed based on the current total number of threads and the maximum number of time intervals. Extract the spectrum of the activity state time series of each thread from the thread activity matrix and perform Fourier transform on it. Calculate the similarity of the spectral components of all threads in the thread pool to obtain a temporal correlation score; For each thread, record its execution time and waiting time. Divide the execution time by the sum of the execution time and waiting time to obtain the resource usage ratio of each thread. Divide the resource usage ratio of each thread by the sum of the resource usage ratios of all threads in the thread pool to obtain the probability distribution for each thread. The entropy value of thread pool resource allocation is calculated based on the probability distribution corresponding to each thread, and the calculated entropy value is used as the degree of resource allocation imbalance. The uncertainty of the thread pool state is obtained by adding the time-series correlation score and the resource allocation imbalance score together.

[0009] Optionally, the steps for obtaining all test task dependency data corresponding to the test cases and calculating task dependency based on the task dependency data are as follows: Obtain the dependency data between all tasks in the test case and convert it into dependency values. ,in , Indicates task Does it depend on the task? The dependency value, if Depends on ,but ,otherwise ; For each task At time step Dependency strength at time The calculation formula is: In the formula, Indicates task In time The strength of the dependency relationship at time indicates the task For other tasks The degree of dependency, where N represents the total number of tasks and the number of tasks in the test case; Indicates task time The execution progress indicates the task Completion level; Calculate each task The standard deviation of dependency strength at all time points within the tested time interval is used as the dependency strength instability value for the corresponding task. The average of the unstable values ​​of the dependency strength of all tasks is taken as the task dependency degree.

[0010] Optionally, the steps for calculating the no-tuning degree based on the thread pool state uncertainty and task dependency are as follows: The thread pool state uncertainty and task dependency are normalized and mapped to the value range of 0-1. The normalized thread pool state uncertainty and task dependency are assigned the same weight, and the no-tuning degree is calculated.

[0011] Optionally, the steps for adjusting the thread pool state in the automated testing of the large-scale intelligent cockpit model, based on whether to adjust the thread pool without requiring adjustment, are as follows: Compare the no-adjustment degree with the preset threshold. If the no-adjustment degree is not less than the preset threshold, then when the thread pool adjustment mechanism is triggered, the thread pool state in the automated test of the intelligent cockpit large model does not need to be adjusted. If the required adjustment degree is less than the preset threshold, then when the thread pool adjustment mechanism is triggered, the thread pool state in the automated testing of the intelligent cockpit large model needs to be adjusted.

[0012] In a second aspect of this invention, an automated testing and analysis system for a large-scale intelligent cockpit model is proposed, the system comprising: Uncertain State Module: When the thread pool adjustment mechanism is triggered, it obtains the resource data of the thread pool during the test case and calculates the uncertainty of the thread pool state based on the resource data. This is used to quantify the current resource utilization distribution and the disorder of resource contention in the thread pool. Task Dependency Module: Obtains all test task relationship dependency data corresponding to the test cases, and calculates the task dependency degree based on the task relationship dependency data, which is used to quantify the strength of the dependency relationship between test tasks; Calculation module: Calculates the degree of no-tuning based on the uncertainty of the thread pool state and the task dependency; Control module: Determines whether to adjust the thread pool state in the automated testing of the large-scale intelligent cockpit model based on the degree of control required.

[0013] Optionally, the state uncertainty module includes: State module: Gets the activity status of each thread in the thread pool at each moment. When a thread is executing a task at a certain time, the activity status value is 1. Thread If the current thread is in an idle state, the activity state value is 0; and a thread activity matrix is ​​constructed based on the current total number of threads and the maximum number of time intervals. Transformation module: Extracts the spectrum of the activity state time series of each thread from the thread activity matrix and performs a Fourier transform on it; Temporal correlation scoring module: Calculates the similarity of the spectral components of all threads in the thread pool to obtain a temporal correlation score; Resource utilization ratio module: For each thread, record its execution time and waiting time, and divide the execution time by the sum of the execution time and waiting time to obtain the resource utilization ratio of each thread; Probability distribution module: Divide the resource usage ratio of each thread by the sum of the resource usage ratios of all threads in the thread pool to obtain the probability distribution corresponding to each thread; Resource allocation imbalance module: Calculates the entropy value of thread pool resource allocation based on the probability distribution corresponding to each thread, and uses the calculated entropy value as the degree of resource allocation imbalance; Comprehensive calculation module: Add the timing correlation score and the resource allocation imbalance to obtain the uncertainty of the thread pool state.

[0014] Optionally, the task-dependent module includes: Dependency Values ​​Module: Retrieves dependency data between all tasks in the test case and converts it into dependency values. ,in , Indicates task Does it depend on the task? The dependency value, if Depends on ,but ,otherwise ; Dependency strength module: for each task At time step Dependency strength at time The calculation formula is: In the formula, Indicates task In time The strength of the dependency relationship at time indicates the task For other tasks The degree of dependency, where N represents the total number of tasks and the number of tasks in the test case; Indicates task In time The execution progress indicates the task Completion level; Dependency Strength Instability Value Module: Calculates the value for each task. The standard deviation of dependency strength at all time points within the tested time interval is used as the dependency strength instability value for the corresponding task. Task Dependency Module: The average of the unstable values ​​of the dependency strength of all tasks is used as the task dependency.

[0015] Optionally, the computing module includes: The thread pool state uncertainty and task dependency are normalized and mapped to the value range of 0-1. The normalized thread pool state uncertainty and task dependency are assigned the same weight, and the no-tuning degree is calculated.

[0016] Optionally, the control module includes: The first comparison module compares the degree of no adjustment with the preset threshold. If the degree of no adjustment is not less than the preset threshold, then when the thread pool adjustment mechanism is triggered, it is not necessary to adjust the thread pool state in the automated test of the intelligent cockpit large model. The second comparison module: If the degree of adjustment is less than the preset threshold, then when the thread pool adjustment mechanism is triggered, the thread pool state in the automated test of the intelligent cockpit large model needs to be adjusted.

[0017] The beneficial effects of this invention are: This invention proposes an automated testing and analysis method and system for a large-scale intelligent cockpit model. When the thread pool adjustment mechanism is triggered, the method acquires the resource data of the thread pool during the testing process of the test cases and calculates the thread pool state uncertainty based on the resource data. It also acquires the dependency data of all test tasks corresponding to the test cases and calculates the task dependency based on the task dependency data. Finally, it calculates the no-adjustment degree based on the thread pool state uncertainty and task dependency. Based on the no-adjustment degree, it determines whether to adjust the thread pool state during the automated testing of the large-scale intelligent cockpit model. This allows for accurate judgment during the automated testing of the large-scale intelligent cockpit model, determining whether the thread pool state adjustment is truly necessary when the thread pool adjustment mechanism is triggered. This avoids unnecessary frequent adjustments, reduces waste of system resources and decreased execution efficiency, ensures system stability, and guarantees the orderly scheduling of test tasks and the stability of the testing process. Attached Figure Description

[0018] The invention will now be further described with reference to the accompanying drawings.

[0019] Figure 1 A flowchart of an automated testing and analysis method for a large-scale intelligent cockpit model; Figure 2 This is a framework diagram of an automated testing and analysis system for a large-scale intelligent cockpit model. Detailed Implementation

[0020] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0021] This invention provides an automated testing and analysis method for a large-scale intelligent cockpit model. See also... Figure 1 , Figure 1 A flowchart illustrating an automated testing and analysis method for a large-scale intelligent cockpit model, provided as an embodiment of the present invention. The method includes the following steps: S1: When the thread pool adjustment mechanism is triggered, obtain the resource data of the thread pool during the test case test, and calculate the thread pool state uncertainty based on the resource data to quantify the current resource utilization distribution and the disorder of resource competition in the thread pool. S2: Obtain all test task dependency data corresponding to the test cases, and calculate the task dependency degree based on the task dependency data to quantify the strength of the dependency relationship between test tasks; S3: Calculate the no-tuning degree based on the thread pool state uncertainty and task dependency; S4: Determine whether to adjust the thread pool in the automated testing of the large-scale intelligent cockpit model based on the degree of no need for adjustment.

[0022] Based on the automated testing and analysis method for a large-scale intelligent cockpit model provided by this invention, the method can determine whether it is truly necessary to adjust the thread pool state when the thread pool adjustment mechanism is triggered during the automated testing of the large-scale intelligent cockpit model. This avoids unnecessary frequent adjustments, reduces waste of system resources and decreases in execution efficiency, ensures system stability, makes test task scheduling orderly, and guarantees the stability of the testing process.

[0023] In one embodiment, S1: When the thread pool adjustment mechanism is triggered, obtain the resource data of the thread pool during the test case test, and calculate the uncertainty of the thread pool state based on the resource data, which is used to quantify the current resource utilization distribution and the disorder of resource competition of the thread pool. In one implementation, the steps for calculating the uncertainty of the thread pool state based on resource data are as follows: Get each thread in the thread pool At every moment Activity status When a thread is executing a task at a given time, its activity state is 1. Thread If the device is in an idle state, the activity state value is 0; specifically: , indicating thread In time At that time, a task was being performed; Thread In time It is currently in an idle state; Constructing the thread activity matrix , Indicates the total number of threads currently in operation; Indicates the maximum number of time points. It is The matrix represents the activity state of each thread at each time step; From the thread activity matrix, extract the time series of the activity state of each thread, and for each thread... Activity status time series Perform a Fourier transform to extract its spectrum. , , Represents thread In frequency The spectral components at that location are used to capture the periodicity of threads; It is a time variable that represents the active state of a thread. It is a frequency variable, representing the fluctuation period of thread activity; Calculate the similarity of the spectral components of all threads in the thread pool to obtain a temporal correlation score. This represents the overall temporal consistency of thread activity in the thread pool, and the formula for calculation is: In the formula, This represents the timing dependency score of the thread pool, indicating the consistency of task scheduling within the thread pool. and Represents thread and threads The spectral components; by calculating the spectral similarity between threads, the temporal consistency of thread pool activity is reflected; For each thread Record its execution time and waiting time ,in: For threads Execution time, For threads Waiting time; Divide the execution time by the sum of the execution time and the waiting time to obtain the resource usage ratio of each thread. The calculation formula is: , Represents thread The resource usage ratio represents the proportion of the total time that a thread spends executing tasks; Divide the resource usage ratio of each thread by the sum of the resource usage ratios of all threads in the thread pool to obtain the probability distribution for each thread; specifically, let the total number of threads in the thread pool be denoted as... Each thread resource usage ratio Convert to the corresponding probability distribution , , Represents thread The probability corresponding to the resource occupancy ratio; The entropy value of thread pool resource allocation is calculated based on the probability distribution corresponding to each thread. This entropy value is used to measure the imbalance in resource allocation, and is then used as the degree of resource imbalance. , The calculation formula is: In the formula, Entropy represents the resource allocation in a thread pool, reflecting the degree of disorder in resource allocation; entropy value The larger the entropy value, the more evenly resources are distributed, and the lower the "determinism" of the system; the smaller the entropy value, the more unevenly resources are distributed, and the higher the uncertainty of the system. Time-series correlation score and uneven distribution of resources Add them together to get the uncertainty of the thread pool state.

[0024] It should be noted that the activity status of each thread in the thread pool can be obtained through system monitoring tools or scheduling system logs. Specifically, it monitors whether each thread is executing a task at any given moment. By recording the thread start and stop times, activity status data for each thread at every moment throughout the entire test is constructed. Thread pool resource data, including the execution time and waiting time of each thread, can be obtained in real time through a performance monitoring system, typically automatically tracked and recorded by the system during task scheduling and execution.

[0025] It's important to note that thread pool state uncertainty is a comprehensive indicator measuring the disorder or instability of resource utilization within a thread pool. In automated testing of large-scale intelligent cockpit models, the thread pool is responsible for scheduling and managing the execution of test tasks, ensuring task parallelism, efficient resource utilization, and sequential task execution. Thread pool state uncertainty assesses stability by quantifying the uneven distribution of resources, the consistency of task scheduling, and the intensity of resource contention among threads. A high thread pool state uncertainty value indicates disordered resource allocation, a large number of idle threads, or severe resource contention, leading to instability. Therefore, in such cases, excessively frequent adjustments to the thread pool size (whether expanding or shrinking) should be avoided. This is because, with high uncertainty, any adjustment to the thread pool size will increase resource consumption and exacerbate the burden, leading to increased context switching, further impacting execution efficiency, and potentially disrupting the inherent scheduling order. For example, suppose that during testing, some tasks are executed frequently while others are idle for extended periods. Expanding or shrinking the thread pool in this unstable state could cause resource fluctuations between tasks, disrupting the execution order and prolonging test completion time. Furthermore, over-expanding the thread pool can lead to performance degradation due to resource contention between tasks, while over-shrinking it can cause delays in task processing. Therefore, when the thread pool state is highly uncertain, it needs to be kept stable to avoid frequent adjustments that could impact overall testing efficiency and resource allocation, thus ensuring the stability of the testing process. In this situation, maintaining the current thread pool configuration is more conducive to improving stable resource utilization, avoiding unnecessary resource waste, ensuring orderly test task scheduling, and ultimately improving testing efficiency and the accuracy of results.

[0026] It's important to note that the advantage of calculating thread pool state uncertainty using the above method is that it comprehensively measures thread pool resource utilization and scheduling efficiency from multiple dimensions, rather than relying solely on single resource usage or load data. Traditional calculation methods typically focus solely on whether threads in the thread pool are busy or how much resource they are using. However, this simplistic approach ignores crucial factors such as the evenness of resource allocation, the consistency of task scheduling, and resource contention between threads. By using Fourier transform to extract spectral analysis of thread pool activity periodicity, calculating the temporal correlation of task scheduling, and measuring entropy in resource allocation, we can quantify stability and resource allocation efficiency from multiple dimensions. This method not only reflects the current load situation but also reveals potential resource contention and task execution inconsistencies, thereby identifying potential instability factors in advance and helping to make more accurate decisions. For example, if resource allocation in the thread pool is highly uneven, with some threads consuming a large amount of computing resources while others are almost idle, traditional calculation methods might fail to identify this. However, entropy calculation can accurately reflect whether resource allocation is reasonable, avoiding instability caused by uneven resource distribution. Therefore, calculating the uncertainty of the thread pool state in this multi-dimensional way can provide more accurate data support for decision-making, reduce the additional overhead caused by excessively frequent adjustments to the thread pool, and ensure stability and efficiency during the testing process.

[0027] In one embodiment, S2: Obtain all test task relationship dependency data corresponding to the test case, and calculate the task dependency degree based on the task relationship dependency data to quantify the strength of the dependency relationship between test tasks; In one implementation, the steps for obtaining all test task dependency data corresponding to the test cases and calculating the task dependency degree based on the task dependency data are as follows: Obtain the dependency data between all tasks in the test case and convert it into dependency values. ,in , Indicates task Does it depend on the task? The dependency value, if Depends on ,but ,otherwise ; For each task At time step Dependency strength at time , indicating task The strength of the dependency on other tasks is calculated based on the task progress, using the following formula: In the formula, Indicates task In time The strength of the dependency relationship at time indicates the task For other tasks The degree of dependency, where N represents the total number of tasks and the number of tasks in the test case; Indicates task In time The execution progress indicates the task Completion level; Calculate each task The standard deviation of dependency strength at all time points within the tested time interval is used as the dependency strength instability value for the corresponding task. The average of the unstable values ​​of the dependency strength of all tasks is taken as the task dependency degree.

[0028] It should be noted that the data acquisition methods involved in each step of the task dependency calculation process must be clear and systematic. First, obtain the dependency data for all tasks in the test case, that is, the dependencies between each task and other tasks. This data is typically obtained through test case design documents, task execution flows, or task dependency graphs; dependencies are inferred through static analysis or execution logs. Specifically, dependency values ​​are set such that... Depends on ,but ,otherwise Next, the execution progress of each task over time can be obtained by monitoring the task execution status in real time through the testing framework. For example, the testing platform can record the actual execution time of the task at each time step, and then calculate the task completion rate. This execution data is usually collected by the testing platform's monitoring system.

[0029] It's important to note that task dependency refers to a comprehensive metric that quantifies the strength and instability of dependencies between test tasks. It measures the degree of interdependence between test tasks and the stability of these dependencies in automated testing. In the automated testing of large-scale intelligent cockpit models, task execution is typically parallel, but strong dependencies may exist between tasks, meaning some tasks can only begin execution after others have completed. Task dependency, by calculating the strength and volatility of dependencies between tasks, helps the system determine whether thread pool adjustments are necessary in the context of multi-task parallel execution. A high task dependency indicates strong or unstable dependencies between test tasks, potentially affecting the task execution order. Dynamic adjustments to the thread pool can impact correct task execution and scheduling. In such cases, frequent adjustments to the thread pool (increasing or decreasing its size) may disrupt the task execution flow, increase context switching overhead, and even lead to task scheduling chaos, wasting system resources and reducing execution efficiency. For example, when a task... Strongly dependent on the task When executing test cases, if the thread pool size is frequently adjusted during task execution, the execution order of tasks may be disrupted, affecting the overall test case execution result. Therefore, when task dependencies are high, frequent adjustments to the thread pool should be avoided. This is because the task execution dependencies are complex or unstable at this time, and excessive thread pool adjustments can lead to system instability, increase resource contention and task scheduling delays, thereby affecting test efficiency and the accuracy of test results. In this situation, maintaining a stable thread pool and avoiding excessive adjustments ensures that tasks are executed sequentially, reduces resource waste, guarantees system stability, ensures the orderly scheduling of test tasks, and ultimately makes the test process more stable and efficient. This includes task start time, end time, and running status.

[0030] It's important to note that the advantage of calculating task dependencies using the above method compared to other methods lies in its comprehensive consideration of the strength of dependencies, task progress, and the stability of dependency relationships. This results in more accurate and meaningful calculations. Traditional task dependency calculation methods may only consider the execution order or the existence of dependencies between tasks, neglecting changes in dependency strength and the dynamic nature of task progress. This leads to overly simplistic representations of complex dependencies, failing to reflect the true execution situation. By incorporating task progress into the dependency strength calculation and combining it with the standard deviation of dependency strength, the dynamic changes in task dependencies can be better captured, especially the volatility and instability during execution. This method not only measures whether tasks depend on each other but also meticulously reflects the tightness of these dependencies and how they change during testing, thus accurately reflecting the system's operational stability. If dependencies are unstable or highly variable, the system's task scheduling may become unreliable, leading to frequent scheduling changes or errors. By calculating the standard deviation of dependencies, it's possible to clearly identify which tasks have tighter dependencies and greater variability, thereby avoiding excessive thread pool adjustments in these cases and ensuring smoother and more efficient system execution. Therefore, calculating task dependencies in this way can more realistically reflect the complex dependencies and execution progress between tasks, thereby helping the system optimize task scheduling and resource allocation, avoid unnecessary frequent adjustments, reduce resource waste, and ensure the stability and reliability of the testing process.

[0031] In one embodiment, S3: The step of calculating the degree of no regulation required based on the thread pool state uncertainty and task dependency is as follows: The thread pool state uncertainty and task dependency are normalized and mapped to the range of 0-1. The normalized thread pool state uncertainty and task dependency are then assigned equal weights, and the no-tuning degree is calculated using the following formula: In the formula, These represent the thread pool state uncertainty and task dependency after normalization. No adjustment is required.

[0032] It should be noted that, under normal circumstances, the sum of the weights assigned to the thread pool state uncertainty and task dependency is 1. The above-mentioned normalization processing methods for removing dimensions include Min-Max normalization, Z-Score normalization, etc., which will not be elaborated here.

[0033] In one embodiment, S4: The step of determining whether to adjust the thread pool state in the automated testing of the large intelligent cockpit model based on the degree of no need for adjustment is as follows: Compare the no-adjustment degree with the preset threshold. If the no-adjustment degree is not less than the preset threshold, then when the thread pool adjustment mechanism is triggered, the thread pool state in the automated test of the intelligent cockpit large model does not need to be adjusted. If the required adjustment degree is less than the preset threshold, then when the thread pool adjustment mechanism is triggered, the thread pool state in the automated testing of the intelligent cockpit large model needs to be adjusted.

[0034] It's important to note that the decision to adjust the thread pool state is made by comparing the NCI with a preset threshold. The core of this step is to make intelligent decisions based on the system's current state. Suppose that during automated testing of a large-scale intelligent cockpit model, the system triggers the thread pool adjustment mechanism, indicating that the system recognizes the need to adjust the thread pool size (expand or shrink) to optimize task execution efficiency. In this case, if the NCI is greater than or equal to the threshold, it indicates that the system is currently in an unstable state, with strong dependencies between tasks or uneven distribution of thread pool resources. Too frequent adjustments in this situation may cause system instability and even exacerbate thread pool chaos. Therefore, the thread pool should not be adjusted; the current state should be maintained to avoid unnecessary resource waste and context switching. For example, if there are strong dependencies between current tasks and significant system load fluctuations, frequent thread pool adjustments may interfere with the task execution order and increase execution time. Conversely, when the NCI is less than the preset threshold, it indicates that the system is running relatively stably, with weak dependencies between tasks and reasonable thread pool resource allocation. In this case, it is safe to adjust the thread pool by increasing or decreasing its size to optimize resource usage and improve testing efficiency. For example, if the system encounters lightweight tasks during execution, the number of threads in the thread pool can be appropriately reduced to avoid excessive resource consumption; or when handling high-load tasks, the thread pool can be expanded to speed up task completion. Therefore, the comparison between NCI and the threshold is a dynamic decision-making mechanism that intelligently determines when to adjust and when to maintain the status quo, thereby ensuring the efficiency of test task scheduling, avoiding unnecessary resource waste and performance degradation, and guaranteeing system stability and the orderly progress of the testing process.

[0035] In one embodiment, the state uncertainty module includes: State module: Gets the activity status of each thread in the thread pool at each moment. When a thread is executing a task at a certain time, the activity status value is 1. Thread If the current thread is in an idle state, the activity state value is 0; and a thread activity matrix is ​​constructed based on the current total number of threads and the maximum number of time intervals. Transformation module: Extracts the spectrum of the activity state time series of each thread from the thread activity matrix and performs a Fourier transform on it; Temporal correlation scoring module: Calculates the similarity of the spectral components of all threads in the thread pool to obtain a temporal correlation score; Resource utilization ratio module: For each thread, record its execution time and waiting time, and divide the execution time by the sum of the execution time and waiting time to obtain the resource utilization ratio of each thread; Probability distribution module: Divide the resource usage ratio of each thread by the sum of the resource usage ratios of all threads in the thread pool to obtain the probability distribution corresponding to each thread; Resource allocation imbalance module: Calculates the entropy value of thread pool resource allocation based on the probability distribution corresponding to each thread, and uses the calculated entropy value as the degree of resource allocation imbalance; Comprehensive calculation module: Add the timing correlation score and the resource allocation imbalance to obtain the uncertainty of the thread pool state.

[0036] In one embodiment, the task-dependent module includes: Dependency Values ​​Module: Retrieves dependency data between all tasks in the test case and converts it into dependency values. ,in , Indicates task Does it depend on the task? The dependency value, if Depends on ,but ,otherwise ; Dependency strength module: for each task At time step Dependency strength at time The calculation formula is: In the formula, Indicates task In time The strength of the dependency relationship at time indicates the task For other tasks The degree of dependency, where N represents the total number of tasks and the number of tasks in the test case; Indicates task In time The execution progress indicates the task Completion level; Dependency Strength Instability Value Module: Calculates the value for each task. The standard deviation of dependency strength at all time points within the tested time interval is used as the dependency strength instability value for the corresponding task. Task Dependency Module: The average of the unstable values ​​of the dependency strength of all tasks is used as the task dependency.

[0037] In one embodiment, the computing module includes: The thread pool state uncertainty and task dependency are normalized and mapped to the value range of 0-1. The normalized thread pool state uncertainty and task dependency are assigned the same weight, and the no-tuning degree is calculated.

[0038] In one embodiment, the control module includes: The first comparison module compares the degree of no adjustment with the preset threshold. If the degree of no adjustment is not less than the preset threshold, then when the thread pool adjustment mechanism is triggered, it is not necessary to adjust the thread pool state in the automated test of the intelligent cockpit large model. The second comparison module: If the required adjustment degree is less than the preset threshold, then when the thread pool adjustment mechanism is triggered, the thread pool state in the automated testing of the intelligent cockpit large model needs to be adjusted. Based on the same inventive concept, this invention also provides an automated testing and analysis system for a large-scale intelligent cockpit model. See also... Figure 2 , Figure 2 This invention provides a framework diagram of an automated testing and analysis system for a large-scale intelligent cockpit model, comprising: Uncertain State Module: When the thread pool adjustment mechanism is triggered, it obtains the resource data of the thread pool during the test case and calculates the uncertainty of the thread pool state based on the resource data. This is used to quantify the current resource utilization distribution and the disorder of resource contention in the thread pool. Task Dependency Module: Obtains all test task relationship dependency data corresponding to the test cases, and calculates the task dependency degree based on the task relationship dependency data, which is used to quantify the strength of the dependency relationship between test tasks; Calculation module: Calculates the degree of no-tuning based on the uncertainty of the thread pool state and the task dependency; Control module: Determines whether to adjust the thread pool state in the automated testing of the large-scale intelligent cockpit model based on the degree of control required.

[0039] Based on the intelligent cockpit large model automated testing and analysis system provided by the embodiments of the present invention, the system can, in accordance with the above method, determine whether it is really necessary to adjust the thread pool state when the thread pool adjustment mechanism is triggered during the automated testing of the intelligent cockpit large model, thereby avoiding unnecessary frequent adjustments, reducing the waste of system resources and the decline in execution efficiency, ensuring system stability, making test task scheduling orderly, and ensuring the stability of the test process.

[0040] The foregoing has provided a detailed description of one embodiment of the present invention, but this description is merely a preferred embodiment and should not be construed as limiting the scope of the invention. All equivalent variations and modifications made within the scope of the claims of this invention should still fall within the patent coverage of this invention.

Claims

1. An automated testing and analysis method for a large-scale intelligent cockpit model, characterized in that, Includes the following steps: When the thread pool adjustment mechanism is triggered, the resource data of the thread pool during the test case is obtained, and the uncertainty of the thread pool state is calculated based on the resource data. Obtain all test task dependency data corresponding to the test cases, and calculate the task dependency degree based on the task dependency data; Calculate the degree of no regulation required based on the uncertainty of the thread pool state and the task dependency; The thread pool state in the automated testing of the large-scale intelligent cockpit model is adjusted based on whether the thread pool needs to be adjusted without requiring control.

2. The automated testing and analysis method for a large-scale intelligent cockpit model according to claim 1, characterized in that, The steps for calculating the uncertainty of the thread pool state based on resource data are as follows: Get the activity status of each thread in the thread pool at each time point. When a thread is executing a task at a given time point, its activity status value is 1. Thread If the current thread is in an idle state, the activity state value is 0; and a thread activity matrix is ​​constructed based on the current total number of threads and the maximum number of time intervals. Extract the spectrum of the activity state time series of each thread from the thread activity matrix and perform Fourier transform on it. Calculate the similarity of the spectral components of all threads in the thread pool to obtain a temporal correlation score; For each thread, record its execution time and waiting time. Divide the execution time by the sum of the execution time and waiting time to obtain the resource usage ratio of each thread. Divide the resource usage ratio of each thread by the sum of the resource usage ratios of all threads in the thread pool to obtain the probability distribution for each thread. The entropy value of thread pool resource allocation is calculated based on the probability distribution corresponding to each thread, and the calculated entropy value is used as the degree of resource allocation imbalance. The uncertainty of the thread pool state is obtained by adding the time-series correlation score and the resource allocation imbalance score together.

3. The automated testing and analysis method for a large-scale intelligent cockpit model according to claim 1, characterized in that, The steps to obtain all test task dependency data corresponding to the test cases and calculate the task dependency degree based on the task dependency data are as follows: Obtain the dependency data between all tasks in the test case and convert it into dependency values. ,in , Indicates task Does it depend on the task? The dependency value, if Depends on ,but ,otherwise ; For each task At time step Dependency strength at time The calculation formula is: In the formula, Indicates task In time The strength of the dependency relationship at time indicates the task For other tasks The degree of dependency, where N represents the total number of tasks and the number of tasks in the test case; Indicates task time The execution progress indicates the task Completion level; Calculate each task The standard deviation of dependency strength at all time points within the tested time interval is used as the dependency strength instability value for the corresponding task. The average of the unstable values ​​of the dependency strength of all tasks is taken as the task dependency degree.

4. The automated testing and analysis method for a large-scale intelligent cockpit model according to claim 1, characterized in that, The steps for calculating the degree of no regulation required based on the thread pool state uncertainty and task dependency are as follows: The thread pool state uncertainty and task dependency are normalized and mapped to the value range of 0-1. The normalized thread pool state uncertainty and task dependency are assigned the same weight, and the no-tuning degree is calculated.

5. The automated testing and analysis method for a large-scale intelligent cockpit model according to claim 1, characterized in that, The steps for adjusting the thread pool state in the automated testing of the large-scale intelligent cockpit model based on whether to adjust the thread pool are as follows: Compare the no-adjustment degree with the preset threshold. If the no-adjustment degree is not less than the preset threshold, then when the thread pool adjustment mechanism is triggered, the thread pool state in the automated test of the intelligent cockpit large model does not need to be adjusted. If the required adjustment degree is less than the preset threshold, then when the thread pool adjustment mechanism is triggered, the thread pool state in the automated testing of the intelligent cockpit large model needs to be adjusted.

6. An automated testing and analysis system for a large-scale intelligent cockpit model, characterized in that, The system includes: Uncertain State Module: When the thread pool adjustment mechanism is triggered, it obtains the resource data of the thread pool during the test case and calculates the uncertainty of the thread pool state based on the resource data. This is used to quantify the current resource utilization distribution and the disorder of resource contention in the thread pool. Task Dependency Module: Obtains all test task relationship dependency data corresponding to the test cases, and calculates the task dependency degree based on the task relationship dependency data, which is used to quantify the strength of the dependency relationship between test tasks; Calculation module: Calculates the degree of no-tuning based on the uncertainty of the thread pool state and the task dependency; Control module: Determines whether to adjust the thread pool state in the automated testing of the large-scale intelligent cockpit model based on the degree of control required.

7. The automated testing and analysis system for a large-scale intelligent cockpit model according to claim 6, characterized in that, The state uncertainty module includes: State module: Gets the activity status of each thread in the thread pool at each moment. When a thread is executing a task at a certain time, the activity status value is 1. Thread If the current thread is in an idle state, the activity state value is 0; and a thread activity matrix is ​​constructed based on the current total number of threads and the maximum number of time intervals. Transformation module: Extracts the spectrum of the activity state time series of each thread from the thread activity matrix and performs a Fourier transform on it; Temporal correlation scoring module: Calculates the similarity of the spectral components of all threads in the thread pool to obtain a temporal correlation score; Resource utilization ratio module: For each thread, record its execution time and waiting time, and divide the execution time by the sum of the execution time and waiting time to obtain the resource utilization ratio of each thread; Probability distribution module: Divide the resource usage ratio of each thread by the sum of the resource usage ratios of all threads in the thread pool to obtain the probability distribution corresponding to each thread; Resource allocation imbalance module: Calculates the entropy value of thread pool resource allocation based on the probability distribution corresponding to each thread, and uses the calculated entropy value as the degree of resource allocation imbalance; Comprehensive calculation module: Add the timing correlation score and the resource allocation imbalance to obtain the uncertainty of the thread pool state.

8. The automated testing and analysis system for a large-scale intelligent cockpit model according to claim 6, characterized in that, The task-dependent modules include: Dependency Values ​​Module: Retrieves dependency data between all tasks in the test case and converts it into dependency values. ,in , Indicates task Does it depend on the task? The dependency value, if Depends on ,but ,otherwise ; Dependency strength module: for each task At time step Dependency strength at time The calculation formula is: In the formula, Indicates task In time The strength of the dependency relationship at time indicates the task For other tasks The degree of dependency, where N represents the total number of tasks and the number of tasks in the test case; Indicates task In time The execution progress indicates the task Completion level; Dependency Strength Instability Value Module: Calculates the value for each task. The standard deviation of dependency strength at all time points within the tested time interval is used as the dependency strength instability value for the corresponding task. Task Dependency Module: The average of the unstable values ​​of the dependency strength of all tasks is used as the task dependency.

9. The automated testing and analysis system for a large-scale intelligent cockpit model according to claim 6, characterized in that, The computing module includes: The thread pool state uncertainty and task dependency are normalized and mapped to the value range of 0-1. The normalized thread pool state uncertainty and task dependency are assigned the same weight, and the no-tuning degree is calculated.

10. The automated testing and analysis system for a large-scale intelligent cockpit model according to claim 6, characterized in that, The control module includes: The first comparison module compares the degree of no adjustment with the preset threshold. If the degree of no adjustment is not less than the preset threshold, then when the thread pool adjustment mechanism is triggered, it is not necessary to adjust the thread pool state in the automated test of the intelligent cockpit large model. The second comparison module: If the degree of adjustment is less than the preset threshold, then when the thread pool adjustment mechanism is triggered, the thread pool state in the automated test of the intelligent cockpit large model needs to be adjusted.

Images