Computing power analysis method, matching method and computer device used in cloud computing environment

Abstract

The invention discloses a computing power analysis method used in a cloud computing environment, a matching method and a computer device. The computing power analysis method used in the cloud computing environment comprises the steps that historical task operation data of different types of computing power nodes in a cloud computing platform are acquired, associated computing power portraits corresponding to the computing power nodes are generated through preprocessing, and then a target model is trained in combination with the historical task operation data to obtain a task-computing power mapping model; performing multi-dimensional dynamic and static analysis on a to-be-executed user calculation task to obtain task feature information; and analyzing the task feature information based on the task-computing power mapping model to obtain analysis information of each type of computing power nodes. According to the method, the required computing power resources and the analysis information of each type of computing power nodes can be accurately predicted according to the dynamic and static analysis feature information of the task before the task is executed, so that accurate computing power identification and intelligent matching are realized, the reasonability and efficiency of task allocation are improved, the resource waste rate is effectively reduced, and the adaptation accuracy in a multi-tenant environment is improved.

Description

Technical Field

[0001] This disclosure relates to the field of cloud computing technology, and in particular to a computing power analysis method, matching method, and computer device for use in a cloud computing environment. Background Technology

[0002] With the development of cloud computing, more and more computing tasks are being migrated to elastic resource pools. Current mainstream cloud platforms such as AWS, Aliyun, and Azure provide a large number of heterogeneous computing resources, including different types and specifications of computing power instances such as CPUs, GPUs, and FPGAs, for users to access on demand. However, accurately determining which type of computing power resource best matches a user's computing task before task submission remains a major challenge in practical applications.

[0003] Traditional resource allocation methods typically employ static template matching or user-defined specification selection, relying heavily on user experience or rough specification of resources for the task. This approach struggles to adapt to complex and diverse application scenarios, especially under highly heterogeneous workloads such as AI training, scientific computing, and video encoding / decoding, where task demands for computing resources exhibit significant dynamism and structural differences. Incompatible resource types or specifications can lead to low resource utilization, prolonged task execution time, and even increased failure rates, severely impacting system efficiency and stability.

[0004] In recent years, some scheduling platforms have attempted to introduce "cost-aware scheduling" or "performance-based scheduling recommendations," but most remain at a superficial level of rule-driven or specific metric-driven recommendations, lacking a deep understanding and adaptation to task execution behavior and computing node capabilities. Meanwhile, the pre-submission evaluation of task characteristics is also relatively rudimentary, often ignoring differences between tasks and failing to achieve personalized recommendations and accurate computational adaptation. Summary of the Invention

[0005] In view of this, the present disclosure provides a computing power analysis method, a matching method, and a computer device for a cloud computing environment, which can solve the problem of lack of accurate computing power identification and intelligent matching before task execution in existing cloud platforms.

[0006] In a first aspect, embodiments of this disclosure provide a method for computing power analysis in a cloud computing environment, including: Obtain historical task execution data for different types of computing power nodes in the cloud computing platform; The historical task execution data is preprocessed, and a corresponding computing power profile is generated based on the preprocessed data. The target model is trained based on the historical task operation data and the associated computing power profile, and the trained model is used as the task-computing power mapping model. Perform multi-dimensional static and dynamic analysis on the user computing tasks to be executed to obtain task feature information; The task feature information is analyzed based on the task-computing power mapping model to obtain analysis information for each type of computing power node.

[0007] Secondly, this disclosure also provides a computing power matching method for a cloud computing environment, including: Based on the aforementioned computing power analysis method for cloud computing environments, the execution performance scores and matching association information of all categories of computing power nodes in the cloud computing platform are obtained. Determine the preset threshold based on the user's computational task to be performed; All computing power nodes whose performance scores are greater than the preset threshold are obtained and stored in the computing power node candidate set.

[0008] Thirdly, this disclosure also provides a computer device, which adopts the following technical solution: The computer device includes: At least one processor; and, A memory communicatively connected to the at least one processor; wherein, The memory stores instructions that can be executed by the at least one processor, which enable the at least one processor to perform either the computing power analysis method for a cloud computing environment or the computing power matching method for a cloud computing environment described above.

[0009] Fourthly, embodiments of this disclosure also provide a computer-readable storage medium storing computer instructions for causing a computer to execute any of the above-described computing power analysis methods or computing power matching methods in a cloud computing environment.

[0010] Fifthly, embodiments of this disclosure also provide a computer program product, including a computer program / instructions that, when executed by a processor, implement the steps of any of the methods described above.

[0011] The computing power analysis method disclosed in this application for cloud computing environments first collects historical task execution data of different types of computing power nodes in a cloud computing platform. This historical task execution data is preprocessed, and a corresponding computing power profile is generated based on the preprocessed data. By collecting historical task execution data of different types of computing power nodes, the performance of various computing power nodes under different tasks can be understood. The corresponding computing power profile generated based on the historical task execution data can intuitively display the performance characteristics and resource usage of each computing power node, helping to quickly understand the characteristics of each node. Next, a target model is trained based on the historical task execution data and the corresponding computing power profile. The trained model serves as a task-computing power mapping model. The training of this model, based on historical data and computing power profiles, has high accuracy and... Reliability is ensured to adapt to the dynamic changes of the cloud computing platform. Next, multi-dimensional static and dynamic analyses are performed on the user computing tasks to be executed to obtain task characteristic information. Multi-dimensional analysis provides a comprehensive understanding of the characteristics of the tasks to be executed, providing a basis for accurately matching tasks and computing resources. Static analysis can assess the basic requirements of the task before it begins, while dynamic analysis can adjust resource allocation in a timely manner during task execution, improving task execution efficiency. Finally, based on the task-computing power mapping model, the task characteristic information is analyzed to obtain analytical information for each type of computing power node. This model can accurately predict the required computing power resources based on the task's characteristic information, improving the rationality and efficiency of task allocation, assigning tasks to the most suitable computing power nodes, fully leveraging the performance advantages of each node, and effectively avoiding resource waste and overload.

[0012] The above description is merely an overview of the technical solution disclosed herein. In order to better understand the technical means of this disclosure and to implement it in accordance with the contents of the specification, and to make the above and other objects, features and advantages of this disclosure more apparent and understandable, preferred embodiments are described below in detail with reference to the accompanying drawings. Attached Figure Description

[0013] To more clearly illustrate the technical solutions of the embodiments of this disclosure, the drawings used in the embodiments will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this disclosure. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0014] Figure 1 This is a flowchart illustrating a computing power analysis method for a cloud computing environment, provided in an embodiment of this disclosure.

[0015] Figure 2 This is a flowchart illustrating the method for generating an associated computing power profile provided in an embodiment of this disclosure.

[0016] Figure 3 A flowchart illustrating the method for obtaining the task-computing power mapping model provided in this embodiment of the disclosure.

[0017] Figure 4 A flowchart illustrating the method for obtaining structural features provided in this embodiment of the disclosure.

[0018] Figure 5 A flowchart illustrating the method for obtaining timing features provided in this embodiment of the disclosure.

[0019] Figure 6 This is a schematic diagram of the structure of a computer device provided in an embodiment of the present disclosure. Detailed Implementation

[0020] The embodiments of this disclosure will now be described in detail with reference to the accompanying drawings.

[0021] It should be understood that the following specific examples illustrate the implementation of this disclosure, and those skilled in the art can easily understand other advantages and effects of this disclosure from the content disclosed in this specification. Obviously, the described embodiments are only a part of the embodiments of this disclosure, and not all of them. This disclosure can also be implemented or applied through other different specific implementation methods, and the details in this specification can also be modified or changed based on different viewpoints and applications without departing from the spirit of this disclosure. It should be noted that, in the absence of conflict, the following embodiments and features in the embodiments can be combined with each other. Based on the embodiments in this disclosure, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this disclosure.

[0022] It should be noted that various aspects of embodiments within the scope of the appended claims are described below. It will be apparent that the aspects described herein can be embodied in a wide variety of forms, and any particular structure and / or function described herein is merely illustrative. Based on this disclosure, those skilled in the art will understand that one aspect described herein can be implemented independently of any other aspect, and two or more of these aspects can be combined in various ways. For example, any number of aspects set forth herein can be used to implement the device and / or practice the method. Additionally, this device and / or method can be implemented using structures and / or functionalities other than one or more of the aspects set forth herein.

[0023] It should also be noted that the illustrations provided in the following embodiments are only schematic representations of the basic concept of this disclosure. The drawings only show the components related to this disclosure and are not drawn according to the number, shape and size of the components in actual implementation. In actual implementation, the form, quantity and proportion of each component can be arbitrarily changed, and the layout of the components may also be more complex.

[0024] Furthermore, specific details are provided in the following description to facilitate a thorough understanding of the examples. However, those skilled in the art will understand that the described aspects can be practiced without these specific details.

[0025] Reference Figure 1 This application discloses a method for computing power analysis in a cloud computing environment, comprising: S100 acquires historical task execution data for different types of computing power nodes in the cloud computing platform.

[0026] S200 preprocesses historical task execution data and generates a related computing power profile for the corresponding computing power node based on the preprocessed data.

[0027] S300 trains the target model based on historical task operation data and associated computing power profiles, and uses the trained model as a task-computing power mapping model.

[0028] S400 performs multi-dimensional static and dynamic analysis on the user computing tasks to be executed to obtain task characteristic information.

[0029] The task feature information includes both static structural features and dynamic temporal features. Further task feature information includes, but is not limited to, numerical indicators such as code structure complexity, number of parallel computing operators, memory access patterns, video memory bandwidth requirements, peak CPU / GPU utilization during historical operation, and I / O throughput.

[0030] S500 analyzes task feature information based on the task-computing power mapping model to obtain analysis information for each type of computing power node.

[0031] The computing power analysis method disclosed in this application for cloud computing environments allocates tasks to the most suitable computing power nodes through accurate task-computing power mapping, effectively avoiding resource waste and overload, and improving the overall resource utilization of the cloud computing platform. Based on task characteristics and the performance of computing power nodes, it selects the optimal computing power resources for tasks, effectively reducing task execution time and improving execution efficiency. Reasonable resource allocation can reduce unnecessary resource investment and lower the operating costs of the cloud computing platform. Simultaneously, by improving resource utilization, more tasks can be processed with the same hardware resources, improving the platform's economic efficiency. This solution, based on historical data and real-time analysis, can adapt to the dynamic changes of the cloud computing platform, flexibly adjusting resource allocation strategies according to different task characteristics and requirements, thus improving the platform's adaptability and flexibility.

[0032] The method for S100 to "obtain historical task execution data of different types of computing power nodes in a cloud computing platform" specifically includes: S110 identifies all types of computing power nodes in the cloud computing platform; computing power nodes can be CPU nodes, GPU nodes, FPGA nodes, or ASIC nodes.

[0033] S120 acquires historical task execution data for each type of computing power node. This historical task execution data is time-series data within a preset period, with the current time node for analyzing the user computing task to be executed serving as the end point of the preset period. This ensures that it includes the latest operating status and performance of the computing power nodes, and clearly shows the impact of business changes on the computing power nodes within the historical period. Furthermore, the data can be indexed by timestamp and node ID and stored in a high-performance time-series database for subsequent querying and modeling. Data acquisition can be performed non-intrusively using an Agent mechanism compatible with mainstream cloud platforms (such as Prometheus and CloudWatch).

[0034] The historical task execution data for CPU nodes includes current clock speed, number of cores, average load, instruction execution rate (IPS), and L1 / L2 cache hit rate; the historical task execution data for GPU nodes includes SM (Streaming Multiprocessor) utilization, memory bandwidth, core temperature, and execution queue status; and the historical task execution data for FPGA or ASIC nodes includes logic unit utilization, data transmission latency, and custom data path activity.

[0035] Reference Figure 2 The method for S200, which "preprocesses historical task execution data and generates a corresponding computing power profile for the computing power node based on the preprocessed data," includes the following methods for generating the associated computing power profile: S210 performs normalization processing on historical task operation data to obtain heterogeneous resource normalization data.

[0036] Specifically, for each metric, find its minimum (min) and maximum (max) across all computing power nodes. For each node's metric value x, normalize it using the following formula: x normalized = (x−min) / (max−min); Through normalization, the value of this index for all nodes is mapped to the interval [0, 1].

[0037] S220 performs dimensionality reduction processing on heterogeneous resource normalized data.

[0038] Specifically, algorithms such as Principal Component Analysis (PCA) or Factor Analysis are used to reduce the dimensionality of normalized data from heterogeneous resources. Taking Principal Component Analysis (PCA) as an example, the specific steps are as follows: Calculate the covariance matrix of the normalized index data; perform eigenvalue decomposition on the covariance matrix to obtain eigenvalues ​​and eigenvectors; select the eigenvectors corresponding to the k largest eigenvalues ​​based on their magnitudes, and these eigenvectors constitute a new low-dimensional space; project the original normalized index data into this new low-dimensional space to obtain the dimensionality-reduced data.

[0039] S230 constructs a related computing power profile for the corresponding computing power node based on the dimensionality-reduced data.

[0040] The associated computing power profile includes at least the parallel processing capability factor, floating-point operation capability, memory throughput factor, network latency index, and historical task failure rate.

[0041] Specifically, the parallel processing capability factor = number of CPU cores × frequency weight, where the frequency weight can be set according to the actual situation, for example, the weight value can be determined according to the performance of the CPU at different frequencies.

[0042] Floating-point arithmetic capability is directly represented by the data after dimensionality reduction; memory throughput factor is also represented by the data after dimensionality reduction; network latency index is represented by the data after dimensionality reduction; and historical task failure rate is represented by the data after dimensionality reduction.

[0043] Furthermore, a unique profile vector ID is generated for each node. Specifically, a hash algorithm can be used, taking the profile element data of the node as input and performing hash calculation to obtain a unique ID. This ID can be used to identify the profile of the node, facilitating subsequent querying and management.

[0044] When a node's status undergoes significant changes (such as hardware upgrades or resource resets), the node's profile needs to be automatically updated. The specific steps are as follows: detect changes in the node's status, which can be achieved by monitoring the node's hardware information, resource configuration, etc. When a significant change is detected, recollect the node's perception data and repeat the above steps (i.e., normalization, dimensionality reduction, and profile construction) to generate a new node profile and profile vector ID.

[0045] Reference Figure 3 For the S300 method of "training the target model based on historical task execution data and associated computing power profiles, and using the trained model as the task-computing power mapping model", the methods for obtaining the task-computing power mapping model include: S310, Determine the target model; the target model is a neural network model or a lightweight model.

[0046] Among them, neural network models such as deep neural networks (DNNs) or long short-term memory networks (LSTMs) utilize their powerful nonlinear fitting capabilities to capture the complex nonlinear mapping relationship between task features, node profiles, and performance scores. Lightweight models such as K-nearest neighbors, decision trees, and support vector machines (SVMs) are used to meet the needs of rapid deployment.

[0047] S320 obtains the performance score of the task on the corresponding computing node based on the historical tasks of each computing node and the corresponding historical task execution data.

[0048] The performance score is a weighted average of latency, cost, and energy consumption during task execution, which is used as the label for the training samples.

[0049] S330 constructs a training dataset based on the historical task execution data, associated computing power profiles, and execution performance scores of all computing power nodes.

[0050] S340 trains the target model based on the training dataset and uses cross-validation to verify the training results, using the target model that meets the training conditions as the task-computing power mapping model.

[0051] Furthermore, the method of S320, which "obtains the execution performance score of a task on a corresponding computing power node based on the historical tasks of each computing power node and the corresponding historical task execution data", specifically includes: S321 obtains latency data, cost data, and energy consumption data during the execution of tasks based on historical task operation data.

[0052] The latency data is the time taken for each task from start to finish, which can be obtained by recording timestamps at the start and end of the task and then calculating the time difference.

[0053] Cost data includes multiple aspects, such as computing resource usage fees and storage fees. Computing resource usage fees can be calculated based on the computing power of the nodes (such as the number of CPU cores, the number of GPUs, etc.) and the duration of use; storage fees are calculated based on the storage capacity and duration of use for the task.

[0054] Energy consumption data is recorded by energy monitoring equipment or software, showing the energy consumed during the execution of each task. For server nodes, power monitors can be installed to monitor power in real time, and then energy consumption can be calculated based on the task execution time.

[0055] S322 calculates a weighted sum of latency data, cost data, and energy consumption data based on preset weights to obtain a score.

[0056] Specifically, domain experts can be invited to subjectively assign weights to latency, cost, and energy consumption based on the characteristics and requirements of the task. For example, for tasks with high real-time requirements, the weight of latency can be increased; for cost-sensitive tasks, the weight of cost can be increased. Alternatively, historical data can be analyzed using machine learning algorithms (such as linear regression, decision trees, etc.) to determine the weights of each indicator. For instance, performance ratings can be used as the dependent variable, and latency, cost, and energy consumption as independent variables, to perform linear regression analysis, obtain the regression coefficients of each indicator, and use these regression coefficients as weights.

[0057] S323 normalizes the scores to obtain the performance score of the task on the corresponding computing power node.

[0058] Specifically, the scores are normalized and mapped to the interval [0, 1]. Specifically, the minimum and maximum scores for all task performance are found; for each task's score (Score), normalization is performed using the following formula: Score normalized = (Score − min) / (max − min). By following the above steps, we can obtain the performance score of each task on the corresponding computing node, which can be used as the label of the training sample for subsequent machine learning model training.

[0059] The S400 method for "performing multi-dimensional static and dynamic analysis of user computing tasks to be executed to obtain task characteristic information" includes: S410 performs static analysis on the user computing task to be executed to obtain several structural features; S420 performs dynamic analysis on the user computing task to be executed to obtain several time-series characteristics; S430 processes structural and temporal features to determine the task feature vector and the corresponding task type, which can be compute-intensive, memory-sensitive, short-duration high-frequency, or GPU-dependent.

[0060] Specifically, after performing feature standardization and encoding on all structural and temporal features in sequence, several task feature vectors are generated.

[0061] Furthermore, methods for obtaining task types can include: taking high-dimensional feature vectors extracted from static and dynamic analysis (including but not limited to numerical indicators such as code structure complexity, number of parallel computing operators, memory access patterns, GPU bandwidth requirements, peak CPU / GPU utilization during historical runs, and I / O throughput) as input, and using unsupervised clustering algorithms (such as K-Means or hierarchical clustering) or representation learning after feature importance filtering through models such as XGBoost to cluster tasks. Subsequently, combining predefined task type labels (such as "computation-intensive," "memory-sensitive," and "GPU-dependent"), and assigning type labels to each cluster through cluster center analysis or expert rule mapping, thereby achieving automatic task type labeling.

[0062] Furthermore, the task feature vector and its corresponding task type are stored in a structured form in a feature library or time-series database. The main body consists of high-dimensional numerical features, specifically including code structure indicators extracted from static analysis (such as function call depth, parallel loop ratio, and explicit memory allocation size), runtime time-series statistics extracted from dynamic analysis (such as mean and variance of CPU utilization, memory bandwidth utilization, and I / O throughput trends), and derived features (such as periodic fluctuation patterns of cache miss rates and thread contention frequency). Simultaneously, the vector also integrates one or more label-type features, such as "computation-intensive" type labels obtained through clustering analysis, "bursting / stable" behavior labels based on resource usage patterns, and "framework dependency labels" extracted from configuration files (such as TensorFlow version requirements). All these features are organized in a vectorized form and associated with unique task identifiers and timestamps to form standardized feature records, which are then used by subsequent mapping models for efficient similarity calculation and matching inference.

[0063] Reference Figure 4 The method for S410, which involves "performing static analysis of the user computing task to be executed to obtain several structural features," includes the following methods for obtaining structural features: S411 performs lexical and syntactic analysis on the source code of the user computing task to be executed to obtain basic features at the code level.

[0064] Among them, the basic characteristics at the code level include function call relationships, dependent libraries, and control flow structure.

[0065] This step allows for a comprehensive understanding of the code's basic components and structure, providing a foundation for subsequent analysis. Function call relationships enable comprehension of the code's execution flow, dependency library information helps determine the code's functional scope and potential performance bottlenecks, and the control flow structure reflects the code's complexity and logical relationships.

[0066] S412 constructs a call graph based on function call relationships and analyzes the call graph to obtain specific computational behaviors in the code.

[0067] Among them, specific computational behavior includes any one of matrix operation behavior, parallel computation behavior, graph structure traversal behavior, and large-scale memory allocation behavior.

[0068] This step allows for in-depth analysis of the core computational behaviors within the code, helping to identify key performance-critical parts of the code. Specific computational behaviors are often the bottlenecks in code performance, and by analyzing these behaviors, targeted optimizations can be made.

[0069] S413, based on the basic characteristics at the code level, specific computational behaviors, the build scripts of the user computational tasks to be executed, container configurations, and the referenced computational frameworks, obtains several structural characteristics.

[0070] Specifically, based on the basic characteristics at the code level, specific computational behaviors, the build script of the user computation task to be executed, container configuration, and the referenced computational framework, the dependency type and degree of the task on underlying hardware resources (such as GPU, multi-core CPU, high memory bandwidth, high-speed I / O, etc.) are comprehensively inferred, that is, the potential demand of the task on hardware resources is inferred, forming a structured feature vector, which is the corresponding structural feature.

[0071] Furthermore, based on the fundamental characteristics and specific computational behaviors at the code level, it can be determined that this computational task has a high dependency on the GPU. The code uses the GPU version of TensorFlow and involves a large number of matrix operations and parallel computations, all of which require GPU support. Simultaneously, due to loading a large pre-trained model, there are also certain requirements for memory bandwidth. The final generated structural characteristics may include "high GPU dependency" and "medium memory bandwidth dependency." Comprehensively considering multiple factors and accurately assessing the code's requirements for underlying hardware resources helps to rationally allocate hardware resources and avoid resource waste or insufficiency.

[0072] Furthermore, based on the basic characteristics at the code level, specific computational behaviors, the build script of the user computation task to be executed, container configuration, and the referenced computing framework, the potential requirements of the task for underlying hardware resources are inferred to form a structured feature vector, that is, to obtain the corresponding structural features. Specifically, this includes basic code-level feature analysis, specific computational behavior analysis, build script analysis, container configuration analysis, and computing framework analysis. Based on the above analysis results, the dimensions of the structured feature vector are determined. For example, it may include dimensions such as CPU core count requirements, GPU count requirements, memory bandwidth requirements, and I / O speed requirements.

[0073] Among them, the basic feature analysis at the code level includes code complexity analysis as well as data type and scale analysis; the specific computation behavior analysis includes parallel computation behavior analysis, computation-intensive and I / O-intensive behavior analysis.

[0074] Code complexity analysis specifically includes: 1) Counting the number of nested loops in the code. The deeper the nesting, the greater the computational load, and the higher the demand for the parallel computing capabilities of multi-core CPUs. For example, in a multi-layered nested matrix multiplication loop, a multi-core CPU can process different matrix element calculations simultaneously, thereby improving computational efficiency; 2) Analyzing the frequency of function calls in the code. Frequent function calls increase system overhead and place certain demands on CPU processing speed. If function calls involve a large amount of data transfer, there may also be potential demands on memory bandwidth and I / O speed.

[0075] The analysis of data types and scale specifically includes: 1) Data type analysis: Different data types differ in memory usage and computational complexity. For example, calculations involving floating-point data are generally more complex than those involving integer data, requiring higher CPU floating-point arithmetic capabilities. If the code extensively uses double-precision floating-point data, a more powerful CPU or GPU may be needed to accelerate computation. 2) Data scale analysis: This involves analyzing the amount of data processed in the code. Large-scale data processing typically requires high memory bandwidth for fast data reading and writing, as well as multi-core CPUs or GPUs for parallel computation. For example, when processing large-scale image datasets, high memory bandwidth is needed to store and transfer image data; GPUs can accelerate image processing and analysis.

[0076] For parallel computing behavior analysis, the specific components include: 1) Explicit parallel code analysis, which checks whether the code uses parallel computing libraries (such as OpenMP, MPI, etc.) or parallel programming structures (such as CUDA kernel functions). If there are explicit parallel computing parts in the code, it indicates that the task requires the parallel computing capabilities of multi-core CPUs or GPUs. For example, loops parallelized using OpenMP can be executed in parallel on multi-core CPUs, improving computation speed. 2) Data parallelism analysis, which analyzes whether there are data parallel computing patterns in the code, i.e., performing the same computational operation on different data elements. Data parallelism is suitable for acceleration on GPUs because GPUs have a large number of computing cores and can process multiple data elements simultaneously. For example, in deep learning, forward and backward propagation computations on multiple samples are typical data parallel computing.

[0077] For the analysis of compute-intensive and I / O-intensive behaviors, the specific categories are: 1) If the code contains a large number of mathematical operations (such as matrix multiplication, convolution, etc.), the task is compute-intensive and has a high demand for the computing power of GPUs or multi-core CPUs. For example, in scientific computing and deep learning, a large number of matrix operations and convolution operations require powerful computing resources to accelerate them. 2) If the code frequently performs I / O operations such as file reading and writing, and network communication, the task is I / O-intensive and has a potential demand for high-speed I / O devices and high memory bandwidth. For example, in data mining and big data processing, it is necessary to read large amounts of data from disks or networks. High-speed I / O devices can improve data reading speed and reduce I / O bottlenecks.

[0078] For build script analysis, the specific steps include: 1) Examining the compilation options in the build script, such as optimization level and parallel compilation options. Higher optimization levels can improve code execution efficiency, but require more computing resources for compilation. Parallel compilation options can utilize multi-core CPUs to accelerate the compilation process; 2) Analyzing the dependent libraries referenced in the build script to understand the hardware resource requirements of these libraries. For example, some deep learning libraries (such as TensorFlow, PyTorch, etc.) usually require GPU support to achieve optimal performance.

[0079] Container configuration analysis specifically includes: 1) Examining the resource limits for CPU, memory, GPU, etc., in the container configuration file. These settings reflect the basic hardware resource requirements of the task during runtime. For example, if the container configuration limits the number of GPUs used, it means the task may require a certain number of GPUs to complete the computation. 2) Checking the environment variable settings in the container configuration. Some environment variables affect the task's use of hardware resources. For example, setting the CUDA_VISIBLE_DEVICES environment variable can specify which GPU devices the task uses.

[0080] For the analysis of computing frameworks, the specific aspects include: 1) Different computing frameworks support parallel computing to varying degrees. For example, deep learning frameworks such as TensorFlow and PyTorch provide rich parallel computing interfaces, which can make full use of the computing power of GPUs and multi-core CPUs. Understanding the parallel computing characteristics of a framework can help infer the parallel computing requirements of a task on hardware resources; 2) Analyzing the memory management mechanism of the computing framework. Some frameworks adopt efficient memory management strategies, which can reduce memory usage and data transfer overhead. If a framework has high requirements for memory management, it may have a potential need for high memory bandwidth.

[0081] Reference Figure 5 The method for "dynamically analyzing the user computing task to be executed and obtaining several time-series features" in S420, namely the method for obtaining time-series features, includes: S421 performs multi-version resource behavior replay on key code segments of user computing tasks to be executed in a programmable sandbox environment based on eBPF and container snapshots, obtaining system call sequences, interrupt frequencies, and resource request patterns.

[0082] Among them, the critical code segment is the code segment that has specific computational behavior.

[0083] Suppose a user's computational task is a Python-based data analysis program, with a critical code segment containing matrix operations as its specific computational behavior. In a programmable sandbox environment based on eBPF and container snapshots, this critical code segment is copied multiple times, each with different resource configurations (such as different memory limits and CPU core counts) and replayed. During replay, system call sequences are recorded, such as file reading and memory allocation system calls; interrupt frequency is analyzed, such as timer interrupts at regular intervals; and resource request patterns are analyzed, such as the large number of memory resource requests at the start of matrix operations. By replaying resource behavior across multiple versions, task execution under different resource environments can be simulated, providing a comprehensive understanding of the task's system call, interrupt, and resource request characteristics in various scenarios. This helps identify potential resource bottlenecks and performance issues, providing a rich data foundation for subsequent analysis.

[0084] S422, based on system call sequence, interrupt frequency, and resource request mode, determines several representative task segments and a dynamic combination scheme of representative task segments; Based on the controllable load injection approach, dynamic combination schemes are processed to generate worst-case resource consumption scenarios and typical resource consumption scenarios.

[0085] Among them, representative task segments are those with resource consumption exceeding the preset amount.

[0086] Specifically, based on the system call sequence, interrupt frequency, and resource request pattern obtained in the previous step, a preset resource consumption threshold is set. For example, when the memory usage of a certain task segment exceeds 500MB, it is considered a representative task segment with resource consumption exceeding the preset threshold. After identifying multiple representative task segments, different dynamic combination schemes are designed, such as combining input data processing segments and matrix operation segments in different orders. Then, based on controllable load injection, these dynamic combination schemes are processed. For example, simulating memory bandwidth saturation, a large number of memory read and write requests are injected into the system to trigger edge behavior, and the performance of the task is observed under worst-case resource consumption scenarios (such as memory bandwidth being completely occupied) and typical resource consumption scenarios (normal resource usage). Identifying representative task segments and dynamic combination schemes, and stimulating different scenarios through controllable load injection, allows for a deeper understanding of the task's performance in complex resource environments. It also reveals the impact of different task segment combinations on resource consumption, providing a basis for optimizing task execution order and resource allocation.

[0087] S423 uses kernel-level probes to collect microarchitectural metrics during the excitation process in different scenarios, generating high-resolution time-series trajectories.

[0088] Among them, microarchitectural metrics include one or more of the following: L3 cache miss rate, PCIe bandwidth utilization, and GPU memory reuse frequency.

[0089] Specifically, during the stimulation of worst-case and typical resource consumption scenarios, kernel-level probes are used to collect microarchitectural metrics. For example, L3 cache miss rate is collected; this metric increases when the program frequently accesses data not in the L3 cache. PCIe bandwidth usage is also collected to understand data transmission on the PCIe bus. GPU memory reuse frequency is collected to observe GPU memory utilization efficiency. These microarchitectural metrics are recorded chronologically to generate high-resolution time-series trajectories, accurate to the nanosecond level. Microarchitectural metrics reflect the resource usage of tasks at the underlying hardware level, and high-resolution time-series trajectories can show the changes of these metrics over time in detail, enabling in-depth analysis of performance bottlenecks, such as whether the performance degradation is due to excessively high L3 cache miss rates or insufficient PCIe bandwidth affecting data transmission speed.

[0090] S424 uses a piecewise linear approximation method based on change point detection to divide resource usage stages.

[0091] Specifically, a piecewise linear approximation method based on change point detection is employed to process nanosecond-level multi-track time-series monitoring data collected through multi-dimensional fine-grained monitoring. Change point detection can identify time points where resource usage changes significantly, dividing the entire task execution process into different resource usage stages. For example, during task execution, the initial stage may be initialization, with low and stable resource usage; as matrix operations begin, resource usage rises rapidly, reaching a computational peak; subsequently, there may be a data synchronization stage where resource usage changes again. Change point detection can accurately identify these time points where resource usage changes significantly, dividing the entire task execution process into different resource usage stages such as the initialization stage, the computational peak stage, and the data synchronization stage. Dividing the resource usage process into stages simplifies the complex task execution process into several stages with different characteristics, facilitating in-depth analysis of each stage and providing a clear understanding of the resource usage patterns at different stages, offering more targeted information for optimizing resource allocation and task scheduling.

[0092] S425 uses a hidden Markov model to analyze the different resource usage stages after division and to identify the types of task operation stages.

[0093] The task execution phase can be categorized as initialization phase, peak computation phase, data synchronization phase, or resource release phase.

[0094] Specifically, by combining Hidden Markov Models (HMMs), the various resource usage stages after division are analyzed, and the task operation stages are automatically identified, such as initialization, peak computation, data synchronization, and resource release. The HMM can infer which task operation stage is currently in based on the probability distribution characteristics of the monitoring data, and automatically identify the task operation stage type. This enables a more accurate understanding of the task execution process and resource usage patterns, which helps to optimize according to the characteristics of different stages. For example, more computing resources can be allocated reasonably during the peak computation stage, and data transmission strategies can be optimized during the data synchronization stage.

[0095] S426 quantifies the resource usage corresponding to each task operation stage type to obtain several time-series features.

[0096] The quantitative representation of resource usage at each stage, including information such as system call frequency and resource request volume, yields corresponding time-series features, namely time-series feature vectors.

[0097] For each identified task execution phase, resource usage is quantified. For example, in the initialization phase, the system call frequency is recorded as 10 times per second, and the resource request amount is 100MB; in the peak computation phase, the system call frequency is 100 times per second, and the resource request amount is 500MB. This quantified information is combined into a time-series feature vector, such as [Initialization phase, system call frequency 10 times / second, resource request amount 100MB], [Peak computation phase, system call frequency 100 times / second, resource request amount 500MB], etc. Quantifying the resource usage of each task execution phase transforms complex resource usage information into comparable and analyzable time-series feature vectors. These time-series features can be used for subsequent task performance evaluation, resource prediction, and optimization decisions.

[0098] In this embodiment, static analysis is performed without running the code. It can only analyze based on the code itself and related configuration information, and cannot fully and accurately reflect the resource consumption and behavior patterns of the task in actual operation. Dynamic analysis, on the other hand, records and analyzes the dynamic behavior of the task through actual running task segments. It can discover problems and characteristics that cannot be detected by static analysis, such as real-time changes in resource requests and performance under different loads. At the same time, the results of dynamic analysis can verify the accuracy of static analysis, supplementing and correcting the results of static analysis. The combination of the two can provide a more comprehensive and accurate understanding of the task's characteristics, providing a more reliable basis for task profiling and computing power matching.

[0099] The S500 method of "analyzing task feature information based on task-computing power mapping model to obtain analysis information for each type of computing power node" includes: taking task feature information as input to the task-computing power mapping model to obtain the execution performance score and matching association information for each type of computing power node. The matching association information includes the matching degree with the task type of the user computing task to be executed, the number of previously successfully run tasks, and the estimated cost.

[0100] Furthermore, the computing power analysis method disclosed in this application for cloud computing environments can be deployed in a Kubernetes environment and run as a Sidecar container service, sharing the feature context with the main business container.

[0101] The computing power analysis method disclosed in this application for cloud computing environments generates associated computing power profiles by acquiring historical task execution data of different types of computing power nodes on a cloud computing platform and training a task-computing power mapping model. After obtaining task feature information through multi-dimensional analysis of user computing tasks to be executed, the task-computing power mapping model is used for analysis. This process can accurately recommend suitable resource types and specifications before the task is officially allocated resources, effectively avoiding the waste of resources when "resources are found to be incompatible only after task deployment", thereby improving the overall system's operating efficiency and response speed.

[0102] Furthermore, by preprocessing historical task operation data and generating associated computing power profiles, and by conducting multi-dimensional analysis of user computing tasks to obtain task characteristic information, a structured resource profiling and task characteristic modeling method is formed. This method can quantitatively visualize resource capabilities, enabling users and platform administrators to intuitively judge the adaptability of various node resources in different task scenarios, providing strong decision support for optimizing resource procurement and cost management.

[0103] The method disclosed in this application covers various heterogeneous resource types, including CPUs, GPUs, and FPGAs, and employs multi-dimensional static and dynamic analysis methods when analyzing user computing tasks, combined with the multi-source characteristics of the tasks. This enables the method to effectively handle various computing tasks such as AI inference, scientific computing, and graphics rendering, achieving a balance between broad generalization ability and high reliability.

[0104] Furthermore, this method trains the model based on historical data, and as new historical task execution data accumulates, it supports a feedback closed-loop mechanism. That is, it can automatically collect task execution results to correct the task-computing power mapping model, continuously improving the accuracy of recommendations and the adaptability of the system during long-term operation, and providing an evolutionary intelligent recommendation framework for complex cloud computing platforms.

[0105] Secondly, this application discloses a computing power matching method for a cloud computing environment, including: S10, Based on the computing power analysis method for cloud computing environment, obtain the execution performance scores and matching association information of all types of computing power nodes in the cloud computing platform; S20, determine the preset threshold based on the user computing task to be executed; S30: Obtain all computing power nodes whose performance scores are greater than a preset threshold and store them in the computing power node candidate set.

[0106] Thirdly, this application discloses a computing power analysis system for a cloud computing environment, used to execute the computing power analysis method for a cloud computing environment disclosed in the first aspect of this application. The system includes: The data acquisition module is used to acquire historical task execution data of different types of computing power nodes in the cloud computing platform; The associated computing power profile generation module is used to preprocess historical task execution data and generate associated computing power profiles for corresponding computing power nodes based on the preprocessed data. The model building module is used to train the target model based on historical task execution data and associated computing power profiles, and to use the trained model as a task-computing power mapping model. The static and dynamic analysis module is used to perform multi-dimensional static and dynamic analysis on the user computing tasks to be executed, and to obtain task feature information. The computing power node information analysis module is used to analyze task feature information based on the task-computing power mapping model to obtain analysis information for each type of computing power node.

[0107] The system operates on mainstream platforms such as Kubernetes, OpenStack, and Aliyun, exhibiting excellent scalability and cross-platform compatibility. All modules support parallel execution, enabling it to handle multi-task concurrent recommendation scenarios.

[0108] Furthermore, all modules are implemented using a microservice architecture and low-latency communication between modules is achieved through gRPC, making them suitable for cloud-native environments with high concurrency task loads.

[0109] Fourthly, this application discloses a computing power matching system for a cloud computing environment, used to execute the computing power matching method for a cloud computing environment disclosed in the second aspect of this application. The system includes: The information acquisition module for each type of computing power node is used to obtain the performance scores and matching association information of all types of computing power nodes in the cloud computing platform based on the computing power analysis method for the cloud computing environment. The preset threshold determination module is used to determine the preset threshold based on the user's computational task to be performed. The node filtering module is used to obtain all computing power nodes whose performance scores are greater than a preset threshold and store them in the computing power node candidate set.

[0110] A computer device according to embodiments of the present disclosure includes a memory and a processor. The memory is used to store non-transitory computer-readable instructions. Specifically, the memory may include one or more computer program products, which may include various forms of computer-readable storage media, such as volatile memory and / or non-volatile memory. The volatile memory may, for example, include random access memory (RAM) and / or cache memory. The non-volatile memory may, for example, include read-only memory (ROM), hard disk, flash memory, etc.

[0111] The processor may be a central processing unit (CPU) or other form of processing unit with data processing capabilities and / or instruction execution capabilities, and may control other components in the computer device to perform desired functions. In one embodiment of this disclosure, the processor is used to run computer-readable instructions stored in the memory, causing the computer device to perform all or part of the steps of the computing power analysis method for a cloud computing environment or the computing power matching method for a cloud computing environment described in the foregoing embodiments of this disclosure.

[0112] Those skilled in the art will understand that, in order to solve the technical problem of how to achieve a good user experience, this embodiment may also include well-known structures such as communication buses and interfaces, and these well-known structures should also be included within the protection scope of this disclosure.

[0113] like Figure 6 This is a schematic diagram of a computer device provided for an embodiment of the present disclosure. It illustrates a structural schematic diagram suitable for implementing the computer device in the embodiments of the present disclosure. Figure 6 The computer device shown is merely an example and should not be construed as limiting the functionality and scope of the embodiments disclosed herein.

[0114] like Figure 6 As shown, a computer device may include a processor (such as a central processing unit, graphics processing unit, etc.), which can perform various appropriate actions and processes based on programs stored in read-only memory (ROM) or programs loaded from storage devices into random access memory (RAM). The RAM also stores various programs and data required for the operation of the computer device. The processor, ROM, and RAM are interconnected via a bus. Input / output (I / O) interfaces are also connected to the bus.

[0115] Typically, the following devices can be connected to the I / O interface: input devices, such as sensors or visual information acquisition devices; output devices, such as displays; storage devices, such as magnetic tapes or hard drives; and communication devices. Communication devices allow the computer device to communicate wirelessly or wiredly with other devices (such as edge computing devices) to exchange data. Although Figure 6 A computer apparatus with various devices is shown, but it should be understood that it is not required to implement or have all of the devices shown. More or fewer devices may be implemented or included alternatively.

[0116] In particular, according to embodiments of this disclosure, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, embodiments of this disclosure include a computer program product comprising a computer program carried on a non-transitory computer-readable medium, the computer program containing program code for performing the methods shown in the flowcharts. In such embodiments, the computer program can be downloaded and installed from a network via a communication device, or installed from a storage device, or installed from a ROM. When the computer program is executed by a processor, all or part of the steps of the computing power analysis method for a cloud computing environment or the computing power matching method for a cloud computing environment described in embodiments of this disclosure are performed.

[0117] For a detailed description of this embodiment, please refer to the corresponding descriptions in the foregoing embodiments, which will not be repeated here.

[0118] A computer-readable storage medium according to embodiments of the present disclosure stores non-transitory computer-readable instructions. When these non-transitory computer-readable instructions are executed by a processor, all or part of the steps of the aforementioned methods for computing power analysis in a cloud computing environment or the methods for computing power matching in a cloud computing environment according to embodiments of the present disclosure are performed.

[0119] The aforementioned computer-readable storage media include, but are not limited to: optical storage media (e.g., CD-ROM and DVD), magneto-optical storage media (e.g., MO), magnetic storage media (e.g., magnetic tape or portable hard drive), media with built-in rewritable non-volatile memory (e.g., memory card), and media with built-in ROM (e.g., ROM cartridge).

[0120] For a detailed description of this embodiment, please refer to the corresponding descriptions in the foregoing embodiments, which will not be repeated here.

[0121] The basic principles of this disclosure have been described above with reference to specific embodiments. However, it should be noted that the advantages, benefits, and effects mentioned in this disclosure are merely examples and not limitations, and should not be considered as essential features of each embodiment of this disclosure. Furthermore, the specific details disclosed above are for illustrative and facilitative purposes only, and are not limitations. These details do not limit the scope of this disclosure to the necessity of employing the aforementioned specific details for implementation.

[0122] In this disclosure, relational terms such as "first" and "second" are used merely to distinguish one entity or operation from another, and do not necessarily require or imply any such actual relationship or order between these entities or operations. The block diagrams of devices, apparatuses, devices, and systems involved in this disclosure are merely illustrative examples and are not intended to require or imply that they must be connected, arranged, or configured in the manner shown in the block diagrams. As those skilled in the art will recognize, these devices, apparatuses, devices, and systems can be connected, arranged, and configured in any manner. Words such as "comprising," "including," "having," etc., are open-ended terms meaning "including but not limited to," and are used interchangeably with them. The terms "or" and "and" as used herein refer to the terms "and / or," and are used interchangeably with them unless the context clearly indicates otherwise. The term "such as" as used herein refers to the phrase "such as but not limited to," and is used interchangeably with it.

[0123] Additionally, as used herein, the "or" used in a list of items beginning with "at least one" indicates a separate list, such that a list of, for example, "at least one of A, B, or C" means A or B or C, or AB or AC or BC, or ABC (i.e., A and B and C). Furthermore, the word "exemplary" does not imply that the described example is preferred or better than other examples.

[0124] It should also be noted that in the systems and methods of this disclosure, the components or steps can be decomposed and / or recombined. These decompositions and / or recombinations should be considered as equivalent solutions to this disclosure.

[0125] Various changes, substitutions, and modifications can be made to the technology described herein without departing from the teachings defined by the appended claims. Furthermore, the scope of the claims of this disclosure is not limited to the specific aspects of the processes, machines, manufactures, events, means, methods, and actions described above. Currently existing or later-developed processes, machines, manufactures, events, means, methods, or actions that perform substantially the same function or achieve substantially the same result as the corresponding aspects described herein can be utilized. Therefore, the appended claims include such processes, machines, manufactures, events, means, methods, or actions within their scope.

[0126] The above description of the disclosed aspects is provided to enable any person skilled in the art to make or use this disclosure. Various modifications to these aspects will be readily apparent to those skilled in the art, and the general principles defined herein may be applied to other aspects without departing from the scope of this disclosure. Therefore, this disclosure is not intended to be limited to the aspects shown herein, but rather to be carried out within the widest scope consistent with the principles and novel features disclosed herein.

[0127] The above description has been given for purposes of illustration and description. Furthermore, this description is not intended to limit the embodiments of this disclosure to the forms disclosed herein. Although numerous exemplary aspects and embodiments have been discussed above, those skilled in the art will recognize certain variations, modifications, alterations, additions, and sub-combinations therein.

Claims

1. A method for computing power analysis in a cloud computing environment, characterized in that, include: Obtain historical task execution data for different types of computing power nodes in the cloud computing platform; The historical task execution data is preprocessed, and a corresponding computing power profile is generated based on the preprocessed data. The target model is trained based on the historical task operation data and the associated computing power profile, and the trained model is used as the task-computing power mapping model. Perform multi-dimensional static and dynamic analysis on the user computing tasks to be executed to obtain task feature information; The task feature information is analyzed based on the task-computing power mapping model to obtain analysis information for each type of computing power node.

2. The computing power analysis method for a cloud computing environment according to claim 1, characterized in that, The acquisition of historical task execution data for different types of computing power nodes in the cloud computing platform includes: Identify all types of computing power nodes in the cloud computing platform; the computing power nodes are CPU nodes, GPU nodes, FPGA nodes, or ASIC nodes. Acquire historical task execution data for each type of computing power node; the historical task execution data is time series data within a preset period, with the current time node for analyzing the user computing task to be executed as the end point of the preset period.

3. The computing power analysis method for a cloud computing environment according to claim 1, characterized in that, The step of preprocessing the historical task execution data and generating a related computing power profile corresponding to the computing power node based on the preprocessed data includes: The historical task execution data is normalized to obtain heterogeneous resource normalized data; The dimensionality reduction process is performed on the normalized data of the heterogeneous resources; Based on the dimensionality-reduced data, a corresponding computing power profile is constructed for the computing power nodes; the corresponding computing power profile includes at least one or more of the following: parallel processing capability factor, floating-point operation capability, memory throughput factor, network latency index, and historical task failure rate.

4. The computing power analysis method for a cloud computing environment according to claim 3, characterized in that, The step of training the target model based on the historical task execution data and the associated computing power profile, and using the trained model as a task-computing power mapping model, includes: Determine the target model; the target model is a neural network model or a lightweight model. Based on the historical tasks of each computing node and the corresponding historical task execution data, a performance score of the task on the corresponding computing node is obtained. A training dataset is constructed based on the historical task execution data, the associated computing power profiles, and the execution performance scores corresponding to all computing power nodes. The target model is trained based on the training dataset, and the training results are verified using cross-validation. The target model that meets the training conditions is used as the task-computing power mapping model.

5. The computing power analysis method for a cloud computing environment according to claim 4, characterized in that, The step of obtaining a performance score for a task on a corresponding computing node based on the historical tasks of each computing node and the corresponding historical task execution data includes: Based on the historical task execution data, obtain latency data, cost data, and energy consumption data during the task execution process; The latency data, cost data, and energy consumption data are weighted and summed based on preset weights to obtain a score. The scores are normalized to obtain the performance score of the task on the corresponding computing node.

6. The computing power analysis method for a cloud computing environment according to claim 4, characterized in that, The user computing task to be executed undergoes multi-dimensional static and dynamic analysis to obtain task feature information, including: Static analysis is performed on the user computing task to be executed to obtain several structural features; Dynamically analyze the user computing tasks to be executed to obtain several temporal characteristics; The structural features and the temporal features are processed to determine the task feature vector and the corresponding task type, wherein the task type is computationally intensive, memory-sensitive, short-term high-frequency, or GPU-dependent.

7. The computing power analysis method for a cloud computing environment according to claim 6, characterized in that, The user computing task to be executed is subjected to static analysis to obtain several structural features, including: Lexical and syntactic analysis is performed on the source code of the user computing task to be executed to obtain basic features at the code level, including function call relationships, dependent libraries, and control flow structure. A call graph is constructed based on the function call relationship, and the call graph is analyzed to obtain specific computational behaviors in the code. The specific computational behaviors are any one of matrix operation behavior, parallel computation behavior, graph structure traversal behavior, and large-scale memory allocation behavior. Based on the basic characteristics at the code level, the specific computational behavior, the construction script of the user computational task to be executed, the container configuration, and the referenced computational framework, several structural characteristics are obtained.

8. The computing power analysis method for a cloud computing environment according to claim 7, characterized in that, The user computing task to be executed is dynamically analyzed to obtain several time-series characteristics, including: In a programmable sandbox environment based on eBPF and container snapshots, multiple versions of resource behavior replay are performed on key code segments of user computing tasks to be executed to obtain system call sequences, interrupt frequencies, and resource request patterns; wherein, the key code segments are code segments that exhibit the specific computing behaviors. Based on the system call sequence, the interrupt frequency, and the resource request pattern, several representative task segments and a dynamic combination scheme for the representative task segments are determined; wherein, the representative task segments are task segments whose resource consumption is higher than a preset amount; Based on the controllable load injection, the dynamic combination scheme is processed to stimulate the worst-case resource consumption scenario and typical resource consumption scenario. High-resolution time-series trajectories are generated by collecting micro-architectural metrics during the excitation process of different scenarios using kernel-level probes. A piecewise linear approximation method based on change point detection is used to divide resource usage stages; The different resource usage stages after division are analyzed by Hidden Markov Model to identify the task operation stage type, which is the initialization stage, peak calculation stage, data synchronization stage or resource release stage. The resource usage corresponding to each task operation stage type is quantitatively represented to obtain several time-series features.

9. The computing power analysis method for a cloud computing environment according to claim 7, characterized in that, The analysis of task feature information based on the task-computing power mapping model to obtain analysis information for each type of computing power node includes: The task feature information is used as input to the task-computing power mapping model to obtain the execution performance score and matching association information for each type of computing power node. The matching association information includes the matching degree with the task type of the user computing task to be executed, the number of previously successfully run tasks, and the estimated cost.

10. A method for matching computing power in a cloud computing environment, characterized in that, include: Based on the computing power analysis method for cloud computing environment according to any one of claims 1-9, the execution performance scores and matching association information of all categories of computing power nodes in the cloud computing platform are obtained; Determine the preset threshold based on the user's computational task to be performed; All computing power nodes whose performance scores are greater than the preset threshold are obtained and stored in the computing power node candidate set.

11. A computer device, characterized in that, The computer device includes: At least one processor; and, A memory communicatively connected to the at least one processor; wherein, The memory stores instructions that can be executed by the at least one processor, which, when executed by the at least one processor, enables the at least one processor to perform the computing power analysis method for a cloud computing environment as described in any one of claims 1-9 or the computing power matching method for a cloud computing environment as described in claim 10.

12. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores computer instructions for causing a computer to perform any one of the computing power analysis methods for a cloud computing environment as described in any one of claims 1-9 or the computing power matching method for a cloud computing environment as described in claim 10.

13. A computer program product comprising computer instructions, characterized in that, When executed by a processor, the computer instructions implement the steps of any one of the computing power analysis methods for a cloud computing environment as described in claims 1-9 or the computing power matching method for a cloud computing environment as described in claim 10.

Images