Parallel program performance trajectory analysis method based on graph neural network

Abstract

The invention relates to a graph neural network-based parallel program performance trajectory analysis method, which comprises the following steps of: executing a certain scale of MPI parallel application programs, and collecting hardware performance data and communication data by utilizing a performance collection tool; performing time slicing on the performance track data; forming a standardized vector of a fixed dimension by using the performance data, and forming an adjacent list by using the communication relation information as the input of a dynamic graph neural network; training the dynamic graph neural network by using an unsupervised learning method based on VAE and obtaining a trained model; inputting the performance trajectory data into the network model, performing forward propagation to obtain an abnormal score of each process in each time slice, and setting a threshold to screen out abnormal points; and determining a root cause by using a function call stack analysis method, and generating a performance analysis report. The method is combined with an unsupervised learning method to automatically identify the program execution exception, and can be suitable for performance trajectory analysis of MPI parallel programs under any scale.

Description

Technical Field

[0001] The present invention belongs to the field of performance analysis tools, and specifically relates to a parallel program performance trajectory analysis method based on graph neural network. Background Art

[0002] Performance trace analysis is one of the important means of performance analysis and tuning of large-scale parallel programs. Performance trace refers to a series of performance data such as execution time, moment, performance counters, etc. collected during the execution of the program. For example, all MPI calls are instrumented, and after the program is executed, the "trace" of the MPI calls can be obtained. In a broad sense, any work based on performance trace analysis can be called performance trace analysis. Performance trace analysis aims to track the state of the program during execution in a more comprehensive and detailed manner, discover performance anomalies more quickly, identify performance bottlenecks, and better guide the performance tuning of the application. As the scale of applications grows, performance analysis technology faces difficulties such as complex inter-process communication, high performance data collection overhead, long performance analysis time, and difficulty in identifying performance bottlenecks. Therefore, the performance analysis and tuning of large-scale parallel applications remains a challenging problem.

[0003] In the field of performance analysis research, program structures or inter-process communications are often abstracted into graph structures, such as data flow graphs, control flow graphs, communication topology graphs, etc. Therefore, graph neural networks have great potential in assisting performance analysis. By leveraging the graph structure modeling and learning capabilities of graph neural networks, developers can more fully understand the complexity and performance characteristics of programs, thereby assisting performance analysis work. This is expected to provide developers with more accurate performance optimization suggestions, accelerate performance analysis and problem diagnosis, and thus improve the overall performance of the program.

[0004] In terms of performance analysis caused by the complexity of large-scale parallel applications, the current challenges mainly include the difficulty in organizing performance data, extracting performance characteristics, and identifying performance bottlenecks. For massive amounts of performance data, organizing it into structured data based on its characteristics is an important basis for effective analysis; for complex parallel program behaviors, extracting key performance characteristics from them requires a lot of time and effort; for a large number of processes and a variety of performance issues, quickly locating and identifying performance bottlenecks becomes an extremely challenging task. These problems limit the comprehensive performance optimization of large-scale parallel applications, so a smarter and more efficient method is needed to solve them. Summary of the invention

[0005] In order to solve the above technical problems, the present invention provides a parallel program performance trajectory analysis method based on graph neural network to improve the efficiency of performance trajectory analysis.

[0006] To achieve the above purpose, the technical solution adopted by the present invention is as follows: A parallel program performance trajectory analysis method based on graph neural network, comprising: Step 1: Collect MPI program performance trajectory data, use PAPI and PMPI to collect hardware performance data and communication performance data. Hardware performance data refers to the hardware register status when the MPI event occurs. Communication performance data includes the event information corresponding to the MPI function and the communication relationship between processes. The collected performance trajectory data is organized into multiple files according to the MPI process number and stored as metadata. Step 2: Set the time slice division parameters, read the organized performance trajectory data, and implement the time slice division by sliding window; Step 3: In a time slice, extract event information for each MPI function in process order, including PAPI event information, MPI event information, and function call stack information, identify the MPI communication function, and take the source process and target process of the communication relationship as a directed edge, and add a time slice ID field to all events and directed edges corresponding to each MPI function; Step 4: Repeat step 3 for each time slice.

[0007] Step 5: Merge all event information and function call stack information within the same time slice and the same process, and convert the merged result into a structured data representation as the node data of the time slice graph; Step 6: Extract the communication relationship with the same source process and target process in the same time slice, that is, the same directed edge, and record the communication frequency as the topological data of the time slice graph; Step 7: Use Word2Ve to vectorize the structured data obtained in step 5, complete the missing node data, and convert the node data of each process in each time slice into node vector information of fixed dimension; Step 8: Read the node vector information obtained in step 7, standardize the node vector information, read the topology data generated in step 6, convert it into an adjacency list sequence, read the communication frequency generated in step 6 as the weight of the directed edge, and form a data set; Step 9: Set the sample sequence length, divide the data set into multiple samples of equal length in a sliding window manner, and sample the training set and prediction set from them; Step 10: Input the training set into the unsupervised learning framework based on dynamic graph neural network, and generate the trained network model after the training process; Step 11: Input the prediction set into the trained network model and calculate the anomaly score for each process in each time slice; Step 12: Use the threshold selection algorithm to select a suitable threshold to filter out the anomalies whose anomaly scores are higher than the threshold, and use the heat map to visualize the filtered anomalies; Step 13: If the root cause of the abnormal point needs to be located, export the time slice ID and process ID of the abnormal point that is greater than the highest threshold, re-execute steps 2-4, and filter out the function stack call information of the abnormal point; Step 14: Use the function call stack information obtained in step 13 to trace back to the program source code, so as to locate the performance bottleneck caused by the source program, and generate a performance analysis report based on the analysis results.

[0008] In step 1, PAPI and PMPI are used to collect hardware performance data, communication performance data and communication relationships during program execution. During collection, required PAPI events and MPI communication events can be selected according to program features.

[0009] In step 2, the time slice division parameters are set to realize the time slice division by sliding window. The specific method is to set two time slice division parameters, duration and interval, where duration represents the size of the time slice and interval represents the interval between two time slices. The start time and end time of each time point are controlled by these two parameters.

[0010] In step 4, the current time slice ID is calculated by (timestamp / interval at this time), and all events of each process in the time slice are sequentially traversed through the performance trajectory data iterator to extract event information and communication relationships, and a time slice ID field is added for each event information and communication relationship.

[0011] In step 5, all event information and function call stack information within the same time slice and the same process are aggregated by using the time slice ID and process ID as keywords, and the results are converted into a structured representation. A row of data represents the performance characteristic data of all events of a process within a time slice.

[0012] In step 6, the time slice ID and <source process ID, target process ID> are used as keywords to aggregate the communication relationship and count the communication frequency. A row of data represents the source, destination and communication frequency of a pair of processes in a time slice.

[0013] In step 7, the structured data obtained in step 5 is vectorized using Word2Ve. The specific method is to set an output dimension parameter for Word2Vec, feed each line of data into Word2Vec as a sentence, output a vector of a fixed dimension for each line, and then fill the missing process data with 0, and finally obtain a feature vector sequence of a fixed dimension.

[0014] In step 9, the sample sequence length (sequence_length) is set, and the data set is divided into multiple samples of equal length in a sliding window manner, from which samples are sampled as training sets and prediction sets. Each sample input to the model contains three parts: (1) Node feature vector, dimension is [sequence_length, number of processes, Word2Vec output dimension]; (2) Edge information, which is an adjacency list sequence of length sequence_length; (3) Edge weights, which is a list of edge weights of length sequence_length.

[0015] In step 10, the training set is input into the unsupervised learning framework based on the dynamic graph neural network, and a trained network model is generated after the training process. The unsupervised learning framework based on the dynamic graph neural network combines GCN, LSTM and VAE to better realize the extraction of spatiotemporal information features and anomaly detection. The network structure is designed as follows: (1) The GCN graph convolution layer is used to replace the original fully connected layer in the LSTM basic unit as the basic block, and the feature matrix of the node and the adjacency matrix of the graph topology As the input at each moment, it is sent to the graph convolution layer for feature extraction. The output of the graph convolution layer is used as the input of the gating unit. moment, for the nodes, according to Moment The feature vector of the node and Moment The cell state of each node , hidden state And neighbor node information, update the topology The cell state of each node , and calculate the topology The new hidden state of the node ; (2) The network framework adopts the VAE-based unsupervised learning method. The network framework consists of two parts: an encoder and a decoder. The encoder and decoder are composed of several basic blocks described in (1) connected in front and back. represents the encoder network parameters, Represents the decoder network parameters. Given an input sequence, it contains a node feature sequence and graph topology sequence ,in , For the sequence length, we use the variational Bayesian estimator to maximize the variational lower bound on the marginal likelihood. , the objective function is as follows:

[0016] in, express The hidden variables at the moment, the purpose of VAE is to reconstruct the sequence in reverse order through the following process : represents the prior distribution, Represents the approximate posterior distribution, first from the prior distribution Medium Sampling , then from Medium Sampling , here we choose the standard normal distribution As The prior. Difficult to handle, VAE introduced To approximate it, use KL divergence To describe and In order to In the case of anomaly detection, we use To represent the reconstruction probability, Represents the hidden variable The expectation of , which represents the approximate posterior distribution of sampling In the case of The log-likelihood of Consistent with the real data, Monte Carlo integration is used here To approximate the expectation, where L represents the number of samples, Indicates times sampling, j represents the jth moment of reconstructed data, Indicates Subsampled latent variables and future observations Given the known situation, the observed data probability.

[0017] In step 11, the calculation method of the anomaly score is specifically to use the reconstruction probability to represent the anomaly score at a certain moment. The higher the score, the more abnormal the program behavior at that moment. Considering that abnormal observations usually occur continuously, the subsequent observations can be used to calculate the anomaly score. The present invention not only learns to reconstruct , and also learn to rebuild After observations, the final anomaly score observation The formula is as follows: , In the formula, the variable Indicates the number of times the anomaly score is calculated or updated at each moment (i.e., the tolerance for detection delay).

[0018] In step 12, the threshold selection algorithm for the anomaly score is specifically designed as follows: ,in is the average of the anomaly score observations, is the standard deviation of the anomaly score observations, A hyperparameter for setting the threshold, set here To filter out abnormal points of different degrees, use the heat map to visualize the filtered abnormal scores and provide an intuitive abnormal distribution area.

[0019] The beneficial effects of the present invention are: The present invention proposes a method for establishing a time slice graph based on performance trajectory, and establishes a graph structure for inter-process communication relationships and performance data; proposes a large-scale performance trajectory analysis method based on dynamic neural networks, and introduces a dynamic graph neural network model to assist performance analysis, thereby capturing the complex temporal and spatial feature information during the execution of large-scale parallel applications, improving the efficiency of performance trajectory analysis, and thus identifying performance bottlenecks more efficiently and accurately. BRIEF DESCRIPTION OF THE DRAWINGS

[0020] Figure 1 This is a design principle diagram of a parallel program performance trajectory analysis method based on a graph neural network of the present invention; Figure 2 This is a schematic diagram of the time slice diagram proposed by the present invention; Figure 3 A schematic diagram of a basic unit of a dynamic graph neural network proposed in the present invention; Figure 4 Schematic diagram of the unsupervised network framework proposed in the present invention. DETAILED DESCRIPTION

[0021] In order to make the purpose, technical solutions and advantages of the present invention more clearly understood, the present invention is further described in detail below in conjunction with the accompanying drawings and examples. It should be understood that the specific examples described herein are only used to explain the present invention and are not intended to limit the present invention. In addition, the technical features involved in each embodiment of the present invention described below can be combined with each other as long as they do not conflict with each other.

[0022] like Figure 1 As shown in FIG. 1 , a design principle diagram of a parallel program performance trajectory analysis method based on a graph neural network of the present invention is shown in FIG. The specific implementation steps of the present invention are as follows: Step 1: Collect MPI program performance trajectory data, and use PAPI and PMPI to collect hardware performance data and communication performance data during program execution. Hardware performance data refers to the hardware register status at the time when the MPI event occurs, and communication performance data includes event information corresponding to the MPI function and the communication relationship between processes. Here, when collecting, the required PAPI events and MPI communication events can be selected according to the program characteristics, and the collected data can be organized into multiple files according to the MPI process number for storage as metadata. For example, the performance trajectory data information collected for MPI events is shown in Table 1. In addition to some common field information, some information related to communication volume and communication time, as well as the source process and destination process of the communication, are mainly selected to facilitate the establishment of communication topology. According to the actual machine situation and application characteristics, the hardware performance data selected PAPI_RES_STL, PAPI_LD_INS, PAPI_SR_INS and PAPI_L2_DCR, the meanings are shown in Table 1; Table 1 Performance trajectory data table

[0023]

[0024] Step 2: Read the organized MPI program performance trajectory data, set the time slice division parameters, implement the time slice division by sliding window, set the duration and interval time slice division parameters, duration indicates the size of the time slice, interval indicates the interval between two time slices, and control the start time and end time of each time point through these two parameters. The specific method is as follows Figure 2 As shown in the figure, according to the two parameters of duration and interval, the execution process of the four processes, process 0, process 1, process 2 and process 3, is divided into , , , Four time slices; Step 3: In a time slice, extract event information for each MPI function in process order, including PAPI event information, MPI event information, and function call stack information, identify the MPI communication function, and treat the source process and target process of the communication relationship as a directed edge, and add a time slice ID field for all events and directed edges corresponding to each MPI function; Step 4: For each time slice, calculate the current time slice ID through (timestamp / interval at this time), and repeat step 3; Step 5: Merge all event information and function call stack information of the same process in the same time slice. The specific method is to aggregate the event information using the time slice ID and process ID as keywords, and convert the result into a structured representation. One row of data represents the performance characteristic data of all events of a process in a time slice. Step 6: Use the time slice ID and <source process ID, target process ID> as keywords to aggregate the communication relationship and count the communication frequency. One row of data represents the source, destination, and communication frequency of a pair of processes in a time slice. Step 7: Use Word2Vec to vectorize the structured data obtained in step 5. The specific method is to set an output dimension parameter for Word2Vec, feed each line of data as a sentence into Word2Vec, output a fixed-dimensional vector for each line, and then fill the missing process data with 0, and finally obtain a fixed-dimensional feature vector sequence; Step 8: Read the node vector information obtained in step 7, standardize the data, read the edge information generated in step 6, convert it into an adjacency list sequence, and read the communication frequency generated in step 6 as the edge weight to form a data set; Step 9: Set the sample sequence length (sequence_length) and divide the data set into multiple samples of equal length in a sliding window manner, from which samples are sampled as training sets and prediction sets. Each sample input to the model consists of three parts: (1) Node feature vector, dimension is [sequence_length, number of processes, Word2Vec output dimension]; (2) Edge information, a sequence of adjacency lists of length sequence_length; (3) Edge weights, a sequence of edge weight lists of length sequence_length.

[0025] Step 10: Input the training set into the unsupervised learning framework based on dynamic graph neural network, and generate the trained network model after the training process. The unsupervised learning framework based on dynamic graph neural network combines GCN, LSTM and VAE to better realize the extraction of spatiotemporal information features and anomaly detection. The network structure is designed as follows: (1) The design of the basic unit is as follows: Figure 3 As shown in the figure, the GCN graph convolution layer is used to replace the original fully connected layer in the LSTM basic unit as the basic block, and the feature matrix of the node and the adjacency matrix of the graph topology As the input at time t, it is sent to the graph convolution layer for feature extraction. The output of the graph convolution layer is passed to multiple gating units, namely the sigmoid and tanh activation function modules. The first sigmoid function in the figure is the forget gate, which receives the output of GCN and determines how much of the cell state from the previous moment to forget , the output of the forget gate is multiplied by The second sigmoid is the input gate, which determines how much new information is written at the current moment. It is multiplied by the candidate memory unit output by tanh to indicate how the new input information affects the cell state at the current moment. The tanh function generates candidate memory units, and its output is multiplied by the output of the input gate and the cell state. Combined with the update, the rightmost sigmoid is the output gate, which determines how much information to output at the current moment. The result of the output gate is related to the cell state. Multiply the result after tanh activation to get the hidden state , which is the output at the current moment. nodes, according to Moment The feature vector of the node and Moment The cell state of each node , hidden state And neighbor node information, update the topology The cell state of each node , and calculate the topology The new hidden state of the node ; (2) The overall network framework design is as follows Figure 4 As shown in the figure, an unsupervised learning method based on VAE is adopted. The network framework consists of two parts: encoder and decoder. The encoder and decoder are composed of several basic blocks (LSTM with graphlayers) described in (1) connected front and back. represents the encoder network parameters, Represents the decoder network parameters. Given an input sequence, it contains a node feature sequence and graph topology sequence ,in , For the sequence length, we use the variational Bayesian estimator to maximize the variational lower bound on the marginal likelihood. , the objective function is as follows:

[0026] in, express The hidden variables at the moment, the purpose of VAE is to reconstruct the sequence in reverse order through the following process : represents the prior distribution, Represents the approximate posterior distribution, first from the prior distribution Medium Sampling , then from Medium Sampling , here we choose the standard normal distribution As The prior. Difficult to handle, VAE introduced To approximate it, use KL divergence To describe and In order to In the case of anomaly detection, we use To represent the reconstruction probability, Represents the hidden variable The expectation of , which represents the approximate posterior distribution of sampling In the case of The log-likelihood of Consistent with the real data, Monte Carlo integration is used here To approximate the expectation, where L represents the number of samples, Indicates times sampling, j represents the jth moment of reconstructed data, Indicates Subsampled latent variables and future observations Given the known situation, the observed data probability.

[0027] Step 11: Input the prediction set into the trained network model and calculate the anomaly score for each process in each time slice. The specific calculation method of the anomaly score is to use the reconstruction probability to represent the anomaly score at a certain moment. The higher the score, the more abnormal the program behavior at that time. Considering that abnormal observations usually occur continuously, the subsequent observations can be used to calculate the anomaly score. The present invention not only learns to reconstruct , and also learn to rebuild After observations, the final anomaly score observation The formula is as follows: , In the formula, the variable Indicates the number of times the anomaly score is calculated or updated at each moment (i.e., the tolerance for detection delay).

[0028] Step 12: Use the threshold selection algorithm to select a suitable threshold to filter out anomalies with anomaly scores higher than the threshold, and use the heat map to visualize the filtered anomalies. The specific design of the threshold selection algorithm for anomaly scores is ,in is the average value of anomaly scores, is the standard deviation of the anomaly score, A hyperparameter for setting the threshold, set here To filter out abnormal points of different degrees, use heat maps to visualize the filtered abnormal scores and provide an intuitive abnormal distribution area; Step 13: If the root cause of the abnormal point needs to be located, export the time slice ID and process ID of the abnormal point that is greater than the highest threshold, re-execute steps 2 to 4, and filter out the function stack call information of the abnormal point; Step 14: Use the function call stack information obtained in step 13 to trace back to the program source code, so as to locate the performance bottleneck caused by the source program, and generate a performance analysis report based on the analysis results.

[0029] The specific embodiments described above further illustrate the objectives, technical solutions and beneficial effects of the present invention in detail. It should be understood that the above description is only a specific embodiment of the present invention and is not intended to limit the present invention. Any modifications, equivalent substitutions, improvements, etc. made within the spirit and principles of the present invention should be included in the scope of protection of the present invention.

Claims

1. A parallel program performance trajectory analysis method based on graph neural network, characterized in that: include: Step 1: Collect MPI program performance trajectory data, use PAPI and PMPI to collect hardware performance data and communication performance data, the hardware performance data includes the hardware register status when the MPI event occurs, and the communication performance data includes the event information corresponding to the MPI function and the communication relationship between processes, and organize the collected performance trajectory data into multiple files according to the MPI process number and store them as metadata; Step 2: Set time slice division parameters, read the organized MPI program performance trajectory data, and implement time slice division by sliding window; Step 3: In a time slice, extract event information for each MPI function in process order, including PAPI event information, MPI event information, and function call stack information, identify the MPI communication function, and take the source process and target process of the communication relationship as a directed edge, and add a time slice ID field to all events and directed edges corresponding to each MPI function; Step 4: Repeat step 3 for each time slice; Step 5: Merge all event information and function call stack information within the same time slice and the same process, and convert the merged result into a structured data representation as the node data of the time slice graph; Step 6: Extract the communication relationships with the same source process and target process in the same time slice, that is, the same directed edges, and record the communication frequency as the topological data of the time slice graph; Step 7: Use Word2Ve to vectorize the structured data obtained in step 5, complete the missing node data, and convert the node data of each process in each time slice into node vector information of fixed dimension; Step 8: Read the node vector information obtained in step 7, standardize the node vector information, read the topology data generated in step 6, convert it into an adjacency list sequence, read the communication frequency generated in step 6 as the weight of the directed edge, and form a data set; Step 9: Set the sample sequence length, divide the data set into multiple samples of equal length in a sliding window manner, and sample the training set and prediction set from them; Step 10: Input the training set into the unsupervised learning framework based on dynamic graph neural network, and generate the trained network model after the training process; Step 11: Input the prediction set into the trained network model and calculate the anomaly score for each process in each time slice; Step 12: Use the threshold selection algorithm to filter out the outliers whose anomaly scores are higher than the threshold, and use the heat map to visualize the filtered outliers; Step 13: Locate the root cause of the abnormal point, export the time slice ID and process ID of the abnormal point that is greater than the threshold, re-execute steps 2-4, and filter out the function stack call information of the abnormal point; Step 14: Use the function call stack information obtained in step 13 to trace back to the MPI program source code, locate the performance bottleneck caused by the source code, and generate a performance analysis report based on the analysis results.

2. According to claim 1, a parallel program performance trajectory analysis method based on graph neural network is characterized in that: In the step 1, the required PAPI events and MPI communication events are selected according to the MPI program characteristics.

3. According to the method for analyzing the performance trajectory of parallel programs based on graph neural network in claim 1, it is characterized in that: In step 2, two time slice division parameters, duration and interval, are set to control the start time and end time of each time slice, duration represents the size of the time slice, and interval represents the interval between two time slices.

4. The method for analyzing the performance trajectory of a parallel program based on a graph neural network according to claim 1, characterized in that: In step 4, the current time slice ID is calculated by the current timestamp and the interval between two time slices, and all events of each process in the time slice are sequentially traversed through the performance trajectory data iterator to extract event information and communication relationships, and a time slice ID field is added for each event information and communication relationship.

5. The method for analyzing the performance trajectory of parallel programs based on graph neural networks according to claim 1, characterized in that: In step 5, all event information is aggregated using the time slice ID and the process ID as keywords, and the result is converted into a structured data representation form.

6. The method for analyzing the performance trajectory of parallel programs based on graph neural networks according to claim 1, characterized in that: In step 6, the time slice ID and <source process ID, target process ID> are used as keywords to aggregate the communication relationship and count the communication frequency.

7. The method for analyzing the performance trajectory of parallel programs based on graph neural networks according to claim 1, characterized in that: In step 7, output dimension parameters are set for Word2Vec, each row of structured data is input into Word2Vec as a sentence, a vector of fixed dimension is output, and then the missing process data is padded with 0 to obtain a feature vector sequence of fixed dimension.

8. The method for analyzing the performance trajectory of parallel programs based on graph neural networks according to claim 1, characterized in that: In step 9, each sample includes three parts: (1) Node feature vector, dimension is [sequence_length, number of processes, Word2Vec output dimension]; (2) Edge information, which is an adjacency list sequence of length sequence_length; (3) Edge weights, which is a list of directed edge weights of length sequence_length.

9. The method for analyzing the performance trajectory of parallel programs based on graph neural networks according to claim 1, characterized in that: In step 10, the unsupervised learning framework based on dynamic graph neural network is designed as follows: Use the GCN graph convolution layer to replace the fully connected layer in the LSTM basic unit as the basic block, and convert the feature matrix of the node and the adjacency matrix of the graph topology As the input at each moment, it is sent to the graph convolution layer for feature extraction, where the output of the graph convolution layer is used as the input of the gating unit. moment, for the nodes, according to Moment The feature vector of the node and Moment The cell state of each node , hidden state And neighbor node information, update the topology The cell state of each node , and calculate the first The new hidden state of the node ; Connect several basic blocks to form an encoder and a decoder of a dynamic graph neural network. represents the encoder network parameters, Represents the decoder network parameters. Given an input sequence, it contains a node feature sequence and graph topology sequence ,in , For the sequence length, we use the variational Bayesian estimator to maximize the variational lower bound on the marginal likelihood. , the objective function is as follows: in, express Hidden variables at time, represents the KL divergence, represents the prior distribution, represents the approximate posterior distribution, Represents the hidden variable The expectation of , which represents the approximate posterior distribution of sampling In the case of The log-likelihood of represents the standard normal distribution, L represents the number of samples, Indicates times sampling, j represents the jth moment of reconstructed data, Indicates Subsampled latent variables and future observations Given the known situation, the observed data probability.

10. The method for analyzing the performance trajectory of parallel programs based on graph neural networks according to claim 1, characterized in that: In step 11, the method for calculating the anomaly score is specifically to calculate the anomaly score observation value : ， In the formula, Indicates the number of times the anomaly score is calculated or updated at each moment, that is, the tolerance for detection delay.

11. The method for analyzing the performance trajectory of parallel programs based on graph neural networks according to claim 1, characterized in that: In step 12, the threshold selection algorithm for the anomaly score is designed as follows: ,in is the average of the anomaly score observations obtained in step 11, is the standard deviation of the anomaly score observations obtained in step 11, A hyperparameter for setting the threshold.

Images