Survey on Graph Neural Network Acceleration: An Algorithmic Perspective

1 Introduction

Graph Neural Networks (GNNs) [Scarselli et al., 2008] are deep learning based models that apply neural networks to graph learning and representation. They are technically skillful [Kipf and Welling, 2017; Veliˇckovi´c et al., 2018] and theoretically supported [Pope et al., 2019; Ying et al., 2019], holding state-of-the-art performance on diverse graph-related tasks [Hamilton et al., 2017; Xu et al., 2019]. Owing to the significant success of GNNs in various applications, recent years have witnessed increasing research interests in GNNs, hastening the emergence of reviews that focus on different research areas. A few reviews [Wu et al., 2020; Zhang et al., 2020; Battaglia et al., 2018] pay close attention to GNN models and generic applications, while others [Wang et al., 2021b; Zhang et al., 2021] place emphasis on specific usages of GNNs. Moreover, hardware-related architectures [Abadal et al., 2021; Han et al., 2021] and software-related algorithms [Lamb et al., 2020] of GNNs are also emphatically surveyed by researchers. Thereby, the above reviews further promote the widespread use of GNNs. However, as GNNs are widely used in emerging scenarios, it is discovered that GNNs are plagued by some obstacles that lead to slow execution. Next, we will discuss obstacles that restrict the efficiency of GNNs execution and present our motivation.

∗Corresponding author

Motivation: why GNNs need acceleration?

First, explosive increase of graph data poses a great challenge to GNN training on large-scale datasets. Previously, many graph-based tasks were often conducted on toy datasets that are relatively small compared to graphs in realistic applications, which is harmful to model scalability and practical usages. Currently, large-scale graph datasets are thereby proposed in literature [Hu et al., 2020a] for advanced research, and at the same time, making GNNs execution (i.e., training and inference) a time-consuming process. Second, under the condition that the over-smoothing issue has been skillfully avoided [Rong et al., 2020], using deeper and more complicated structures is a promising way to acquire a GNN model with good ability of expression [Chiang et al., 2019; Rong et al., 2020], which, on the other hand, will increase the time cost of training a well-expressive model. Third, special devices, such as edge devices, generally have strict time restrictions on GNN training and inference, especially in a time-sensitive task. Due to the limited computing and storage resources, the training and inference time on such devices can easily become intolerable. Therefore, it is still an urgent need to accelerate GNNs in both training and inference.

However, no literature has systematically investigated acceleration methods for GNNs at the algorithm level. Practically, algorithm level optimizations not only promote the model accuracy but also accelerate the model learning [Chen et al., 2018b; Bojchevski et al., 2020]. We argue that algorithmic acceleration methods for GNNs will greatly benefit processes of training and inference, and at the same time, the overall performance of GNN frameworks [Fey and Lenssen, 2019; Wang et al., 2019a], since a well-designed framework equipped with an optimized algorithm can empirically gain a two-fold promotion [Lin et al., 2020]. In consequence, despite some insightful reviews on graph-related frameworks and hardware accelerators, a thorough review on algorithmic acceleration methods for GNNs is highly expected, which is exactly the goal and the focus of this work.

In this paper, we provide a comprehensive survey on algorithmic acceleration methods for GNNs, in which graph-level and model-level optimizations are emphatically focused. To summarize, we highlight our contributions as follows:

1. New Taxonomy: we classify existing methods into five categories via a double-level taxonomy that jointly considers optimized factors and core mechanisms (see Section 2).
2. Comprehensive Review: we provide a comprehensive survey on existing methods and introduce these methods by categories. And we emphatically focus on common grounds and unique points among these methods (see Section 3).
3. Thorough Comparison: we summarize the performance of training time of typical acceleration methods and further give a thorough comparison from an overall perspective, in which correlations among these methods are particularly highlighted (see Section 4).
4. Future Prospects: based on the overall comparison, we discuss some potential prospects of GNNs acceleration for reference (see Section 5).

2 Preliminary and Taxonomy

In this section, we first introduce the background of GNNs and the conventional execution including processes of training and inference. Then, we propose a taxonomy of acceleration methods for GNNs. Notations and the corresponding descriptions used in the rest of the paper are given in Table 1.

2.1 Background of GNNs andModel Execution

To efficiently capture hidden patterns in graphs, GNNs provide an inspired idea of combining the design of modern neural networks and graph learning [Wu et al., 2020]. With the background of deep learning, many variants of GNN are proposed by adding particular mechanisms to the original GNN model, e.g., Graph Convolutional Networks (GCNs) [Kipf and Welling, 2017], Graph Attention Networks (GATs) [Veliˇckovi´c et al., 2018], and Graph Isomorphism Networks (GINs) [Xu et al., 2019]. As with most artificial neural networks (ANNs), the execution of GNNs contains processes of training and inference. Herein, we take the GCN model as an exemplar for formulated introduction, owing to its powerful ability and the widespread usage of handling graph-related tasks. Generally, given A and X as input, the forward propagation in the l-th layer in GCN training can be formulated as:

The backpropagation is performed by updating W via the computed gradient. Distinctly, Equation 1 implies the forward propagation to be an iterative computing process in a layered manner, which takes non-trivial cost in terms of time and storage. As for inference, the trained model is utilized to infer and acquire hidden representation for downstream tasks. In consequence, for training, it is time-consuming to obtain the well-trained W; for inference, attempts of deploying the inference to resource-limited devices make an urgent demand for inference efficiency.

2.2 Taxonomy of AccelerationMethods

A double-level taxonomy of existing algorithmic acceleration methods for GNNs is illustrated in Figure 1. First, methods are classified into two major categories according to the optimized factor. "Graph-level" denotes that the optimization is conducted on graphs used for training and inference by modifying topology or density of graphs. "Model-level" denotes that the optimization is made on GNNs' model containing modifications to the model structure or weight. Further, we divide these methods into five categories based on their mechanisms, i.e., graph sampling, graph sparsification, graph partition, GNN simplification, and GNN compression. As an exemplar, "Graph Sampling" denotes that graph sampling methods are utilized to accelerate the training convergence of GNNs. At the final level, we label these methods by their optimization objectives, e.g., graph sampling gains acceleration by reducing the computation cost. Detailed discussions are given in Section 3.

3 AccelerationMethods for GNNs

In this section, we discuss five types of algorithmic acceleration methods that respectively focus on graph-level and model-level optimizations. For each category of methods, we first introduce the fundamental and the way for acceleration from an overall aspect. Then, we exemplify typical work belonging to these categories and highlight their correlations.

3.1 Graph-level Optimizations

Graph Sampling

Conventional training of GNNs, especially GCNs, is executed in a full-batch manner, restricting model update to once per epoch and thus slows down the training convergence. As illustrated in Figure 2(a), graph sampling methods generally select partial nodes in one node's neighborhood or one layer in a graph to acquire subgraphs for subsequent training, which makes efficient computation for model training. We formulate the sampling-based training process of GNNs using GraphSAGE [Hamilton et al., 2017] as an exemplar:

Functions Aggregate and Update denote processes for aggregating hidden features from neighbors and updating features, respectively. As we can observe, the sampling method restricts size of N(v) to SN(v) and decreases the computation cost in subsequent step, instead of generating h conventionally with a whole graph utilized. Moreover, sampling methods utilize a mini-batch strategy in training and update the model once per batch, which accelerates the model convergence and promotes the training efficiency.

Please note that, sampling methods for GNN training are generally diverse and are different in design purposes, e.g., for accelerating model training or reducing memory usage. Herein, we pay close attention to methods that benefit the training speed and convergence. Next up, by referring to the practice of previous literature [Liu et al., 2021b], we orderly discuss these methods as follows.

• Node-wise sampling methods: node-wise sampling is a fundamental sampling method that focuses on each node and its neighbors in a training graph. GraphSAGE [Hamilton et al., 2017] is an inductive learning framework in which a sampling method and a mini-batch strategy are first proposed to benefit the training. In the sampling process, GraphSAGE randomly selects 2-hop neighbors for each node in a batched manner. The aggregation process is performed based on the sampled result. Taking inspiration from GraphSAGE, VRGCN [Chen et al., 2018a] restricts the number of neighbors per node to an arbitrarily small size for alleviating the exponential growth of the receptive field.
• Layer-wise sampling methods: layer-wise sampling can be regarded as an algorithmic improvement of node-wise sampling. Since node-wise sampling suffers from exponential expansion of multi-hop neighbors, layer-wise sampling alleviates the heavy overhead by sampling a fixed number of nodes

in each layer based on pre-computed probability. Typically, FastGCN [Chen et al., 2018b] independently samples a certain number of nodes per layer and reconstructs connections (of nodes) between two successive layers according to A of the training graph. Based on a hierarchical model as well, the sampling process of AS-GCN [Huang et al., 2018] is layerdependent and probability-based. It samples nodes according to the parent nodes sampled in the upper layer.

• Subgraph-based sampling methods: subgraph-based sampling generates subgraphs for training in a two-step manner: sampling nodes and constructing connections (edges). The graph samplers are varied compared to the first two sampling methods. For instance, GraphSAINT [Zeng et al., 2020] utilizes three samplers, i.e., node sampler, edge sampler, and random walk sampler, to sample nodes (or edges) and construct a subgraph in each batch. Moreover, subgraph sampling can be parallelized at the processing unit level with a training scheduler aided [Zeng et al., 2019], making the training efficient and easily scalable. Such parallelization takes good advantage of the property that subgraphs can be sampled independently.
• Heterogeneous sampling methods: heterogeneous sampling is designed to accelerate the training and handle the graph heterogeneity, i.e., imbalanced number and type of neighbors in a node's neighborhood. HetGNN [Zhang et al., 2019] resolves the heterogeneity issue by traversing and collecting neighbors in a random walk manner. The collected neighbors are grouped by type and are further sampled based on the visit frequency. To achieve balanced neighboring distribution, HGSampling is proposed in HGT [Hu et al., 2020b] to sample different types of nodes orderly. HGSampling is probability-based and ensures a balanced sampling result among diverse neighbors.

Graph Sparsification

Graph sparsification is a classic technique for speeding up many fully dynamic graph algorithms [Eppstein et al., 1997]. As illustrated in Figure 2(b), graph sparsification methods typically remove task-irrelevant edges in a graph by designing a specific optimization goal. Recent graph sparsification methods propose to sparsify input graphs before they are fed into a GNN model, which makes efficient computation and memory access for model training. To be generic, we formulate the sparsification method as follows:

In Equation 5, the Sparse function can be implemented via two schemes: 1) designing a heuristic sparsification algorithm; 2) building a learnable module (e.g., sparsifier) for sparsification. After processing, the graph (Asp) is highly sparse in general, where task-irrelevant edges are removed to reduce subsequent computation and redundant memory access cost in GNN. Moreover, graph sparsification methods can be skillfully leveraged to reduce the communication latency during training, thus accelerating GNN training in the hardware [Arka et al., 2021]. Next, we discuss these methods according to their schemes (i.e., heuristic or learnable).

• Heuristic sparsification: DropEdge [Rong et al., 2020] proposes to randomly remove edges in each training epoch, which aims to resolve the over-smoothing issue in deep GNN training. Instead of designing a global optimization goal, random edge dropping is heuristic and ensures both fast execution of algorithm and randomness of graph. FastGAT [Srinivasa et al., 2020] presents a resistance-based spectral graph sparsification solution to remove useless edges, reducing the number of attention coefficients in a GAT model. Thereby, both training and inference are well accelerated.
• Learnable module for sparsification: NeuralSparse [Zheng et al., 2020a] and SGCN [Li et al., 2020] cast graph sparsification as an optimization problem. NeuralSparse utilizes a deep neural network (DNN) to learn a sparsification strategy based on the feedback of downstream tasks in training. It casts graph sparsification as an approximative objective of generating sparse k-neighbor subgraphs. SGCN formulates graph sparsification as an optimization problem and resolves it via an alternating direction method of multipliers (ADMM) approach [Boyd et al., 2011]. Additionally, GAUG [Zhao et al., 2021] proposes two variants: GAUG-M utilizes an edge predictor to acquire probabilities of edges in a graph, and modifies input graphs based on the predicted probabilities; GAUG-O integrates the edge predictor and GNN model to jointly promote edge prediction and model accuracy.

Other literature aims to accelerate GNN inference, such as UGS [Chen et al., 2021] and AdaptiveGCN [Li et al., 2021]. UGS utilizes lottery ticket hypothesis to sparsify input graphs and a GNN model iteratively. AdaptiveGCN builds an edge predictor module to remove task-irrelevant edges for inference acceleration on both CPU and GPU platforms.

Graph Partition

Graph partition has been an NP-hard problem with the goal of reducing the original graph to smaller subgraphs that are constructed by mutually exclusive node groups [Buluc¸ et al., 2016]. As graph data goes enormous, studies have previously deployed GNN execution on diverse platforms, such as a distributed system with multiple GPUs equipped, which places high demands for data communication in systems. Thereby, to accelerate GNN execution on such systems, graph partition methods are introduced to reduce the communication cost and maintain the load balance (efficient communication and memory usage). Figure 2(c) illustrates a simple paradigm of graph partition using a vertex-cut strategy. We generally formulate the process of graph partition as follows:

The Blocki here is a set of divided nodes used to generate a Subgraphi. The generated sugraphs can be deployed on different devices for distributed training. Since graph partition methods are generally diverse and are widely used in a distributed system, one can easily find some classic partition methods, such as METIS [Karypis and Kumar, 1998], are well employed to reduce the communication cost. Herein, we discuss typical partition methods for efficient GNN training that focus on different optimization targets.

• Graph partition for generic GNN training: DistGNN [Md et al., 2021] applies a vertex-cut graph partition method to full-batch GNN training to reduce communication across partitions. The partition method preserves replicas for nodes segmented with their neighbors, which benefits the execution of delayed remote partial feature aggregation. DistDGL [Zheng et al., 2020b] partitions a graph using METIS, and further colocates nodes/edges features with graph partitions. To reduce the number of cross-partition edges and achieve a good balance, DistDGL formulates the objective as a multi-constraint problem. In this way, the original METIS is improved to solve the edge balance issue in graph partition during training.
• Graph partition for sampling-based GNN training: sampling is becoming a time-consuming process in training largescale graphs. BGL [Liu et al., 2021a] utilizes a graph partition method to minimize cross-partition communication in sampling subgraphs during GNN training, in which multisource breadth first search (BFS) and greedy assignment heuristics are fully leveraged to ensure both multi-hop locality and balanced nodes distribution. Cluster-GCN [Chiang et al., 2019] partitions a graph into multiple clusters using METIS, after which these clusters are randomly sampled to construct subgraphs for subsequent training. Cluster-GCN reduces memory usage in training and achieves a fast training speed on a deep GCN model. Pagraph [Lin et al., 2020] proposes a GNN-aware graph partition method to ensure balanced partitions in workload and avoid cross-partition visits in the sampling process as much as possible. Specifically,

partitioned subgraphs are extended to include L-hop neighbors and corresponding edges for an L-layer model, allowing independent training on each graph partition.

3.2 Model-level Optimizations

GNN Simplification

GNN simplification is a model-specific method that simplifies operation flows in an GNN, targeting the improvement of computation efficiency in GNN training and inference. The layer propagation in a widely used GNN model, i.e., GCN, is given in Equation 1, in which linear aggregation of neighboring information in spatial dimension and nonlinear activation are combined to update node representations. However, through recalling the design of classic yet straightforward classifiers, recent literature has argued that the efficiency of GNNs can be further promoted by simplifying redundant operations, despite the current outstanding performance. Since simplified GNNs are used in different tasks, we discuss typical models according to the model generality (or specificity). · Generic simplified GNN: SGC [Wu et al., 2019] removes the nonlinear activation, i.e., ReLU, between each layer to decrease model complexity, with only the final Softmax function preserved to generate probabilistic outputs. The simplified propagation is given as follows:

The linearized model is lightweight and includes a parameterfree part, where the initial X times S can be pre-processed without using weight matrices W. Leveraging above properties, SGC achieves significant acceleration on the training speed while maintaining comparable accuracy in many generic tasks, such as text and graph classification.

· Special simplified GNN with tasks related: LightGCN [He et al., 2020] and UltraGCN [Mao et al., 2021] aim to simplify the GNN model for learning embeddings from user-item interaction graphs in a recommender system. In a generic GCN layer, aggregated features are further processed via two operations: linear transformation using a learnedWand nonlinear activation. LightGCN finds that feature transformation and nonlinear activation hardly benefit collaborative filtering by empirically exploring ablation studies on NGCF [Wang et al., 2019b]. Therefore, LightGCN abandons the above two operations and drops self-loops in A to simplify the GCN model used in collaborative filtering. Moreover, UltraGCN identifies the issue in message passing of LightGCN and resolves it with a simpler structure. LightGCN passes messages by stacking multiple layers, which can cause an over-smoothing problem and is harmful to training efficiency. UltraGCN thus proposes to abandon explicit message passing among multiple layers and get approximate ultimate embeddings directly, yielding 14× speedup over LightGCN in terms of training.

GNN Compression

Current deep learning applications heavily rely on enormous data and complicated models in general. Such a model is well-representative but contains hundreds of millions of parameters, making the model training an intolerable timeconsuming process. Model compression is a technique that compresses a complicated model, such as a DNN [Cheng et al., 2017], to a lightweight one with typically fewer parameters preserved, which is widely used to yield acceleration in training and inference and save the computation cost. By reviewing an emerging trend of applying model compression to GNNs for efficient computation, we discuss these methods according to their mechanisms.

• Model quantification: as a particular quantification technique, binarization skillfully compresses model parameters and graph features in GNNs to yield significant acceleration in inference. Binarized DGCNN [Bahri et al., 2021] and BiGCN [Wang et al., 2021a] similarly introduce binarization strategies into GNNs to speed up model execution and reduce memory consumption. Degree-quant [Tailor et al., 2021] proposes a quantization-aware training method for GNNs to enable model inference with low precision integer (INT8) arithmetic, achieving up to 4.7× speedup on CPU platform.
• Knowledge distillation: knowledge distillation (KD) [Hinton et al., 2015] is a technique that extracts knowledge from a teacher model and injects it into a smaller one with similar performance maintained, which at the same time, yields acceleration on model inference. Yang et al. [Yang et al., 2020] propose to preserve the local structure of a teacher model via a special-designed module, which helps the knowledge transfer from a trained larger model to a smaller one. Other literature [Yang et al., 2021] presents an effective KD framework where a specially built student model can jointly benefit from a teacher model and prior knowledge. Moreover, TinyGNN [Yan et al., 2020a] bridges the gap of extracting neighbor information between a teacher mode and a student model via a combined use of a peer aware module and a neighbor distillation strategy. The learned student model can achieve dozens of times speedup in inference than the teacher model.

4 Comparison and Analysis

In this section, comparison of model efficiency (reflected by relative training time) is given in Figure 3. Note that methods in different categories are partitioned by chain lines and these in the same category are compared using the same dataset and platform. All data is collected from literature [Liu et al., 2021b; Mao et al., 2021; Md et al., 2021]. We also provide overall summary and comparison of existing methods in Tables 2 & 3. We pay special attention to the following aspects. · GNN backbone denotes which models can be applied with acceleration methods. Sampling methods are generally con-

1:[Hamilton et al., 2017],2:[Chen et al., 2018a],3:[Chen et al., 2018b],4:[Huang et al., 2018],5:[Zeng et al., 2019],6:[Zeng et al., 2020], 7:[Zhang et al., 2019],8:[Hu et al., 2020b],9:[Rong et al., 2020],10:[Srinivasa et al., 2020],11:[Zheng et al., 2020a],12:[Li et al., 2020], 13:[Zhao et al., 2021],14:[Chen et al., 2021],15:[Zheng et al., 2020a],16:[Md et al., 2021],17:[Zheng et al., 2020b],18:[Liu et al., 2021a], 19:[Chiang et al., 2019],20:[Lin et al., 2020],21:[Wu et al., 2019],22:[He et al., 2020],23:[Mao et al., 2021],24:[Bahri et al., 2021], 25:[Wang et al., 2021a],26:[Tailor et al., 2021],27:[Yang et al., 2020],28:[Yang et al., 2021],29:[Yan et al., 2020a]

Table 3: Comparison among algorithmic acceleration methods from multiple aspects.

ducted on spatial-based GNNs, e.g., GCNs, to capture neighboring connection and representation in a spatial dimension. A typical sparsification method can be regarded as a sampling method conditionally by viewing each edge as the sampling target. Moreover, sparsification methods have wider backbones than sampling methods for application. Partition methods are mainly applied to special GNNs that are spatialpartible for subgraphs generation. Existing simplification methods merely design simplified GCNs for application, owing to straightforward propagation rules and the widespread usage of GCNs. Compression methods have been previously used for DNNs acceleration [Cheng et al., 2017], in which techniques that used, such as quantification, can also be deployed on GNNs and most variants with modifications.

• Acceleration phase denotes which phases in GNN execution are accelerated. Since training is the most timeconsuming phase, accelerating training is the primary objective for all these methods. Herein, we highlight some special cases. Sparsification methods using learnable modules like UGS [Chen et al., 2021] and AdaptiveGCN [Li et al., 2021] adopt sparsified graphs in inference to yield speedup. Simplification methods generally benefit both training and inference in speed, since the cost of training and inference in a simplified model is always saved. Compression methods provide model-level optimizations in terms of model weights and structures. Same as simplification methods, the benefit of GNN compression is favorable to both training and inference.
• Optimization objective denotes which objectives are optimized to yield a speedup. Most methods reduce the computation cost (abbreviated as Compt.) to accelerate GNN execution, such as sampling methods. Generally, the cost of aggregating neighbor representation in a full-batch manner largely depends on the number of edges. Sparsification methods drop useless edges in a graph to reduce memory access (abbreviated as Mem.) cost, thus yielding a speedup to a certain de-

gree. Partition methods reduce communication cost (abbreviated as Com.) by minimizing cross-partition edges. Moreover, memory-aware partition methods achieve load balance according to a reasonable allocation of memory, which benefits GNN execution in terms of speed.

• General and special application denotes the general application and the special application respectively. Generally, all GNN based methods can resolve graph-related tasks such as (semi-supervised) node classification. Specially, sampling methods, e.g., AS-GCN[Huang et al., 2018], GraphSAINT[Zeng et al., 2020], can be leveraged to eliminate variance that introduced by probabilistic sampling. By regarding redundant edges in a graph as noise, sparsification methods such as NeuralSparse[Zheng et al., 2020a] can learn a specific strategy to remove task-irrelevant edges, achieving an effect of denoising. Instead of randomly generating subgraphs, partition methods can divide a graph into many smaller ones by using clustering algorithms, where size of each cluster is similar for load balance. Simplification methods such as LightGCN [He et al., 2020] fuse a simplified GNN models with processes such as collaborative filtering, which is designed for a recommendation task. By adding virtual edges to graphs in a teacher model and a student model, compression methods such as KD-GCN [Yang et al., 2020] can extend the process of KD to dynamic graph learning.

5 Summary and Future Prospects

This paper provides a comprehensive survey on algorithmic acceleration methods for GNNs, in which methods in existing literature are systematically classified, discussed, and compared according to the proposed taxonomy. We believe the execution of GNNs can be promoted to gain higher efficiency via graph and model level optimizations, benefiting graphrelated tasks in diverse platforms. Despite recent success and

• great leap of GNN acceleration methods, there are still challenges to be solved in this research field. We thereby suggest some promising prospects for future research as follows.
• Acceleration for dynamic graphs: most acceleration methods adopt static graphs for research. A dynamic graph, however, is more flexible in topology and feature spaces than a static one, making it hard to apply these methods to dynamic graphs directly. Compression methods like KD-GCN [Yang et al., 2020] and Binarized DGCNN [Bahri et al., 2021] utilize a special module to extend the use to dynamic graphs, providing a nascent exemplar of dynamic graphs acceleration.
• Hardware-friendly algorithms: hardware-friendly algorithms benefit the model (or algorithm) execution on general platforms by leveraging hardware features. Recent literature [Liu et al., 2021c] that targets to bridge the gap between graph sampling algorithms and the hardware feature, utilizes locality-aware optimizations to yield a considerable speedup in graph sampling. However, this raises the question of what characteristics should be carefully considered to design a hardware-friendly algorithm for GNN acceleration.
• Algorithm and hardware co-design: different to domainspecific hardware accelerators for GNNs, e.g., HyGCN [Yan et al., 2020c] directly tailoring hardware datapath to GNNs based on the execution-semantic characterization for GNNs [Yan et al., 2020b], algorithm and hardware co-design explores the design space with both algorithm and hardware awareness. Taking a productive co-design in a related field (i.e., graph processing) as an example, GraphDynS [Yan et al., 2019] first optimizes the execution semantic of graph traversal algorithms and then tailors its hardware datapath to the optimized execution semantic. Similarly, in GNN acceleration, a synergy effect on optimization can be achieved by a simultaneous design of algorithm and hardware efforts in general. However, to our knowledge, there has been rare existing work on this perspective so far.

Acknowledgments

This work was supported by the Strategic Priority Research Program of Chinese Academy of Sciences (Grant No. XDC05000000), National Natural Science Foundation of China (Grant No. 61732018 and 61872335), AustrianChinese Cooperative R&D Project (FFG and CAS) (Grant No. 171111KYSB20200002), CAS Project for Young Scientists in Basic Research (Grant No. YSBR-029), and CAS Project for Youth Innovation Promotion Association.