A parallel program performance trajectory analysis method based on graph neural network

Abstract

The present invention relates to a parallel program performance trajectory analysis method based on graph neural network, which includes: executing a certain scale of MPI parallel application programs, and using a performance acquisition tool to collect hardware performance data and communication data; time slicing the performance trajectory data; forming the performance data into a standardized vector of fixed dimension, and forming the communication relationship information into an adjacency list as the input of a dynamic graph neural network; using an unsupervised learning method based on VAE to train the dynamic graph neural network and obtain a trained model; inputting the performance trajectory data into the network model, obtaining the abnormality score of each process in each time slice after forward propagation, setting a threshold to filter out abnormal points; using a function call stack analysis method to determine the root cause, and generating a performance analysis report. The present invention combines the unsupervised learning method to automatically identify program execution anomalies, and is applicable to the performance trajectory analysis of MPI parallel programs at 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 networks. Background Art

[0002] Performance trace analysis is one of the key methods for performance analysis and tuning of large-scale parallel programs. A performance trace refers to a series of performance data, such as execution time, moment, and performance counters, collected during program execution. For example, by instrumenting all MPI calls, a "trace" of MPI calls can be obtained after the program is executed. Broadly speaking, any analysis based on performance traces can be referred to as performance trace analysis. Performance trace analysis aims to more comprehensively and detailedly track the state of program execution, more quickly discover performance anomalies, identify performance bottlenecks, and thus better guide application performance tuning. As the scale of applications grows, performance analysis technology faces challenges such as complex inter-process communication, high performance data collection overhead, long performance analysis times, and difficulty identifying performance bottlenecks. Therefore, performance analysis and tuning of large-scale parallel applications remains a challenging problem.

[0003] In the field of performance analysis research, program structure or inter-process communication is often abstracted into graph structures, such as data flow graphs, control flow graphs, and communication topology graphs. 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 gain a more comprehensive understanding of program complexity and performance characteristics, thereby assisting performance analysis. This is expected to provide developers with more accurate performance optimization recommendations, accelerate performance analysis and problem diagnosis, and ultimately improve overall program performance.

[0004] When it comes to performance analysis, the complexity of large-scale parallel applications presents significant challenges, including difficulties in organizing performance data, extracting performance characteristics, and identifying performance bottlenecks. Organizing massive amounts of performance data into structured data based on their characteristics is crucial for effective analysis. Extracting key performance characteristics from complex parallel program behavior requires significant time and effort. Rapidly locating and identifying performance bottlenecks is a challenging task, given the large number of processes and diverse performance issues. These challenges hinder comprehensive performance optimization of large-scale parallel applications, necessitating a smarter, more efficient approach. 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 object, the technical solution adopted by the present invention is as follows:

[0007] A parallel program performance trajectory analysis method based on graph neural network, including:

[0008] Step 1: Collect MPI program performance trace 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 event information corresponding to the MPI function and the communication relationship between processes. The collected performance trace data is organized into multiple files according to the MPI process number and stored as metadata.

[0009] Step 2: Set the time slice parameters, read the organized performance trace data, and implement time slice division using a sliding window approach;

[0010] Step 3: Within 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 and target processes of the communication relationship as a directed edge. Add a time slice ID field to all events and directed edges corresponding to each MPI function.

[0011] Step 4: Repeat step 3 for each time slice.

[0012] Step 5: Merge all event information and function call stack information of the same process within the same time slice, and convert the merged result into a structured data representation as the node data of the time slice graph;

[0013] Step 6: Extract the communication relationships with the same source and target processes within the same time slice, that is, the same directed edges, and record the communication frequency as the topological data of the time slice graph;

[0014] 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 fixed-dimensional node vector information;

[0015] 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;

[0016] Step 9: Set the sample sequence length and divide the dataset into multiple samples of equal length using a sliding window method, from which the training set and prediction set are sampled;

[0017] 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;

[0018] Step 11: Input the prediction set into the trained network model to calculate the anomaly score for each process in each time slice;

[0019] Step 12: Use the threshold selection algorithm to select an appropriate threshold to filter out anomalies with anomaly scores higher than the threshold, and use a heat map to visualize the filtered anomalies;

[0020] Step 13: If the root cause of the anomaly needs to be located, export the time slice ID and process ID of the anomaly that is greater than the maximum threshold, and repeat steps 2-4 to filter out the function stack call information of the anomaly.

[0021] Step 14: Use the function call stack information obtained in step 13 to trace back to the program source code, thereby locating the performance bottleneck caused by the source program, and generate a performance analysis report based on the analysis results.

[0022] 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 characteristics.

[0023] In step 2, the time slice division parameters are set to implement time slice division through a sliding window method. Specifically, the duration and interval parameters are set. Duration represents the size of the time slice, and interval represents the interval between two time slices. These two parameters control the start and end time of each time point.

[0024] 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 trace data iterator to extract event information and communication relationships, and a time slice ID field is added to each event information and communication relationship.

[0025] 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.

[0026] 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.

[0027] In step 7, the structured data obtained in step 5 is vectorized using Word2Vec. The specific method is to set an output dimension parameter for Word2Vec, feed each line of data into Word2Vec as a sentence, 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.

[0028] In step 9, set the sample sequence length (sequence_length) and divide the dataset into multiple samples of equal length using a sliding window. Samples are taken from these samples as training sets and prediction sets. Each sample input to the model consists of three parts:

[0029] (1) Node feature vector, with the dimension [sequence_length, number of processes, Word2Vec output dimension];

[0030] (2) Edge information, which is an adjacency list sequence of length sequence_length;

[0031] (3) Edge weights, which is a list of edge weights with a length of sequence_length.

[0032] In step 10, the training set is input into the unsupervised learning framework based on the dynamic graph neural network. After the training process, a trained network model is generated. 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:

[0033] (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, and the output of the graph convolution layer is used as the input of the gate unit. moment, for the nodes, according to Moment The feature vector of a node and Moment Cell state of a node , hidden state And neighbor node information, update the topology Cell state of a node , and calculate the topology The new hidden state of the node ;

[0034] (2) The network framework adopts the unsupervised learning method based on VAE. The network framework consists of two parts: encoder and decoder. The encoder and decoder are composed of several basic blocks described in (1) connected front and back. represents the encoder network parameters, Represents the decoder network parameters, given an input sequence, containing node feature sequences 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:

[0035]

[0036] 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 mid-sampling , then from mid-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 express the reconstruction probability, Represents the latent variable The expectation of , which represents the approximate posterior distribution of the sample In the case of The log-likelihood of Consistent with the real data, the Monte Carlo integration is used here To approximate the expectation, where L represents the number of samples, Indicates the sampling times, j represents the jth moment of reconstructed data, Indicates the Subsampled latent variables and future observations Given the known situation, the observed data probability.

[0037] 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:

[0038] ,

[0039] 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).

[0040] In step 12, the threshold selection algorithm for the anomaly score is specifically designed as follows: ,in is the mean 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.

[0041] The beneficial effects of the present invention are:

[0042] This paper proposes a method for establishing a time slice graph based on performance trajectories, establishing a graph structure for inter-process communication relationships and performance data; and proposes a large-scale performance trajectory analysis method based on dynamic neural networks. By introducing a dynamic graph neural network model to assist performance analysis, the method captures 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

[0043] Figure 1 This is a design principle diagram of a parallel program performance trajectory analysis method based on graph neural network in the present invention;

[0044] Figure 2This is a schematic diagram of the time slice diagram proposed by the present invention;

[0045] Figure 3 This is a schematic diagram of the basic unit of the dynamic graph neural network proposed by the present invention;

[0046] Figure 4 Schematic diagram of the unsupervised network framework proposed in this invention. DETAILED DESCRIPTION

[0047] In order to make the objectives, technical solutions, and advantages of the present invention more clearly understood, the present invention is further described in detail below with reference to the accompanying drawings and examples. It should be understood that the specific examples described herein are only intended to illustrate the present invention and are not intended to limit the present invention. In addition, the technical features involved in the various embodiments of the present invention described below may be combined with each other as long as they do not conflict with each other.

[0048] like Figure 1 The figure shows the design principle diagram of a parallel program performance trajectory analysis method based on a graph neural network in the present invention. The specific implementation steps of the present invention are as follows:

[0049] 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 of MPI event occurrence, and communication performance data includes event information corresponding to the MPI function and the communication relationship between processes. Here, during collection, the required PAPI events and MPI communication events can be selected according to 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 and destination processes of the communication, is mainly selected to facilitate the establishment of the communication topology. According to the actual machine situation and application characteristics, the hardware performance data selected are PAPI_RES_STL, PAPI_LD_INS, PAPI_SR_INS and PAPI_L2_DCR, and their meanings are shown in Table 1;

[0050] Table 1 Performance trajectory data table

[0051]

[0052] Step 2: Read the organized MPI program performance trajectory data, set the time slice division parameters, and implement the time slice division by sliding window. Set the duration and interval time slice division parameters. Duration represents the size of the time slice, and interval represents the interval between two time slices. These two parameters control the start time and end time of each time point. The specific method is as follows: Figure 2 As shown, according to the two parameters of duration and interval, the execution process of the four processes of process 0, process 1, process 2 and process 3 is divided into 、 、 、 Four time slices;

[0053] Step 3: Within 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 and target processes of the communication relationship as a directed edge. Add a time slice ID field to all events and directed edges corresponding to each MPI function.

[0054] Step 4: For each time slice, calculate the current time slice ID using (timestamp / interval) and repeat step 3.

[0055] Step 5: Merge all event information and function call stack information for the same time slice and process. This is done by aggregating the event information using the time slice ID and process ID as keywords. The result is converted into a structured representation. A single row of data represents the performance characteristics of all events for a process within a time slice.

[0056] 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. A row of data represents the source, destination, and communication frequency of a pair of processes in a time slice.

[0057] 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 row of data as a sentence into Word2Vec, and output a fixed-dimensional vector for each row. Then, the missing process data is padded with zeros, and finally a fixed-dimensional feature vector sequence is obtained.

[0058] 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;

[0059] Step 9: Set the sample sequence length (sequence_length) and divide the dataset into multiple samples of equal length using a sliding window. Samples are taken from these as training and prediction sets. Each sample input to the model consists of three parts:

[0060] (1) Node feature vector, with the dimension [sequence_length, number of processes, Word2Vec output dimension];

[0061] (2) Edge information, a sequence of adjacency lists of length sequence_length;

[0062] (3) Edge weights, a sequence of edge weight lists of length sequence_length.

[0063] Step 10: Input the training set into the unsupervised learning framework based on dynamic graph neural network to 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:

[0064] (1) The design of the basic unit is as follows Figure 3 As shown, the GCN graph convolution layer replaces 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 decides how much of the cell state from the previous moment to forget , the output of the forget gate is multiplied with Multiplication, the second sigmoid is the input gate, which determines how much new information to write 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 a candidate memory unit, 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 , this is the output at the current moment. nodes, according to Moment The feature vector of a node and Moment Cell state of a node , hidden state And neighbor node information, update the topology Cell state of a node , and calculate the topology The new hidden state of the node ;

[0065] (2) Overall network framework design Figure 4 As shown in the figure, the 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, containing node feature sequences 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:

[0066]

[0067] 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 mid-sampling , then from mid-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 express the reconstruction probability, Represents the latent variable The expectation of , which represents the approximate posterior distribution of the sample In the case of The log-likelihood of Consistent with the real data, the Monte Carlo integration is used here To approximate the expectation, where L represents the number of samples, Indicates the times sampling, j represents the jth moment of reconstructed data, Indicates the Subsampled latent variables and future observations When the data is known, probability.

[0068] Step 11: Input the prediction set into the trained network model and calculate the anomaly score for each process in each time slice. The 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 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:

[0069] ,

[0070] 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).

[0071] Step 12: Use the threshold selection algorithm to select a suitable threshold to filter out the anomalies with anomaly scores higher than the threshold, and use the heat map to visualize the filtered anomalies. The specific design of the anomaly score threshold selection algorithm is as follows: ,in is the average of the 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;

[0072] Step 13: If you need to locate the root cause of the anomaly, export the time slice ID and process ID of the anomaly that is greater than the maximum threshold, and repeat steps 2 to 4 to filter out the function stack call information of the anomaly.

[0073] Step 14: Use the function call stack information obtained in step 13 to trace back to the program source code, thereby locating the performance bottleneck caused by the source program, and generate a performance analysis report based on the analysis results.

[0074] 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 are only specific embodiments of the present invention and are 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 trace 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. The communication performance data includes the event information corresponding to the MPI function and the communication relationship between processes. The collected performance trace 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 MPI program performance trajectory data, and implement time slice division through a sliding window method; Step 3: Within 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 and target processes of the communication relationship as a directed edge. 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 and target processes within 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 fixed-dimensional node vector information; 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 and divide the dataset into multiple samples of equal length using a sliding window method, from which the training set and prediction set are sampled; 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 to calculate the anomaly score for each process in each time slice; Step 12: Use the threshold selection algorithm to filter out outliers with anomaly scores higher than the threshold, and use a heat map to visualize the filtered outliers; Step 13: Locate the root cause of the anomaly, export the time slice ID and process ID of the anomaly that is greater than the threshold, and re-execute steps 2-4 to filter out the function stack call information of the anomaly; 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. A parallel program performance trajectory analysis method based on graph neural network according to claim 1, characterized in that: In step 1, required PAPI events and MPI communication events are selected according to MPI program characteristics.

3. The method for analyzing parallel program performance trajectory based on graph neural network according to claim 1, 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, where duration represents the size of the time slice and interval represents the interval between two time slices.

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

5. The method for analyzing parallel program performance trajectory based on graph neural network 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.

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

8. The method for analyzing parallel program performance trajectory based on graph neural network according to claim 1, characterized in that: In step 9, each sample consists of three parts: (1) Node feature vector, with the dimension [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 are lists of directed edge weights of length sequence_length.

9. The method for analyzing parallel program performance trajectory based on graph neural network 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 node feature matrix 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 gate unit. moment, for the nodes, according to Moment The feature vector of a node and Moment Cell state of a node , hidden state And neighbor node information, update the topology Cell state of a node , and calculate the first The new hidden state of the node ; Connect several basic blocks to form the encoder and decoder of the dynamic graph neural network. represents the encoder network parameters, Represents the decoder network parameters, given an input sequence, containing node feature sequences 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 The hidden variables at time, represents the KL divergence, represents the prior distribution, represents the approximate posterior distribution, Represents the latent variable The expectation of , which represents the approximate posterior distribution of the sample In the case of The log-likelihood of represents the standard normal distribution, L represents the number of samples, Indicates the times sampling, j represents the jth moment of reconstructed data, Indicates the Subsampled latent variables and future observations When the data is known, probability.

10. The method for analyzing parallel program performance trajectory based on graph neural network according to claim 1, characterized in that: In step 11, the calculation method of the anomaly score is specifically to calculate the anomaly score observation value : ， Where, 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 parallel program performance trajectory based on graph neural network 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