A dynamic hierarchical rendering method, system and application for ultra-large scale graph data

Abstract

The application belongs to the technical field of computer graphics and big data visualization, and discloses a dynamic hierarchical rendering method, system and application for super-large graph data.The rendering method comprises a dynamic graph layering mechanism based on structural entropy, a super-aggregated node-subgraph rendering architecture and a polymorphic coordination layout calculation strategy.The application solves the challenges existing in rendering large-scale data volume graphs by conventional means, i.e., browser memory overflow caused by direct rendering of million-level nodes at a time and resource waste caused by repeated rendering due to the absence of a cache mechanism, and provides a solution for large-scale data visualization rendering.

Description

TECHNICAL FIELD

[0001] The present application belongs to the technical field of computer graphics and big data visualization, and particularly relates to a dynamic hierarchical, super-aggregated node-subgraph structure and polymorphic collaborative layout computing method for ultra-large scale graph. BACKGROUND

[0002] With the development of big data information visualization, the demand for visualization of ultra-large scale data graphs of single information networks in subfields is increasing, which puts higher requirements on the rendering capacity of single machines. These ultra-large scale graph data have multi-level structures and complex link relationships, and are essentially heterogeneous networks. Not all information is what users want to obtain, and on the contrary, excessive redundant information can reduce the effectiveness of information and also occupy limited information transmission channels.

[0003] The constituent elements of a graph are nodes and edges. If the number of nodes reaches the level of millions, the entire screen (a 1080P screen has 1080*1920=2073600 pixels) will be filled. Considering the rendering of edges and the calculation of event binding and position (coordinates) on nodes, the memory space of a single machine can be fully occupied.

[0004] The layout result of a graph basically determines the degree of visualization. In the face of a node with a huge volume and complex structure, the traditional visualization layout has a chaotic visual effect and is very time-consuming in layout calculation.

[0005] Through the above analysis, the challenges of existing big data graph rendering technology are:

[0006] Massive data transmission and structure analysis take a long time, resulting in slow loading speed;

[0007] It can be very difficult to render more than a million nodes and edges, especially after rendering, to support interactive operations on nodes and edges;

[0008] The visualization layout calculation of graph results is difficult.

[0009] The combination of super-aggregated node-subgraph structure based on structural entropy hierarchical and polymorphic collaborative layout calculation for rendering graphs is a targeted solution for large-scale data. This method automatically divides a single information network with a huge volume into hierarchical levels under three element conditions, and then forms a super node set-subgraph structure. Through hierarchical rendering in the front end, the mode of "super node association and multi-subgraph rendering" is achieved. At the same time, the GPU CUDA parallel computing platform is used to solve the efficiency problem of graph layout calculation. The present application can solve the following problems:

[0010] Massive heterogeneous multi-element graph data can be automatically layered and aggregated.

[0011] Break through the bottleneck of single screen simultaneous rendering of million nodes: through the super node-subgraph mode on-demand loading, the performance pressure of single frame rendering can be effectively reduced.

[0012] Introduce GPU-CUDA parallel computing platform to accelerate layout calculation and improve rendering efficiency. SUMMARY

[0013] To solve the challenges existing in the traditional big data graph visualization rendering, that is, to ensure the storage, calculation and transmission performance of million-level graph data reliable while realizing high semantic visualization graph in the front end, a million-level graph visualization method based on dynamic hierarchical, super node-subgraph structure and GPU accelerated layout calculation is disclosed to realize the processing and rendering of super large scale graph data.

[0014] The technical solution is as follows: a dynamic hierarchical rendering system for super large scale graph data, the method comprising the following specific steps:

[0015] S1, construct metadata dynamic hierarchical rules through three dimensions of structural entropy, edge density and community stability, realize automatic hierarchical of graph and graph structure feedback mechanism;

[0016] S2, super-aggregate encapsulation is performed on each layer of graph data to form a super node+subgraph dual model structure, and the front end loads the subgraph of the specific super node on demand according to the sight distance;

[0017] S3, dynamically divide the load to each CUDA core processing.

[0018] In step S1, the metadata dynamic hierarchical is completed, including:

[0019] S11, structural entropy calculation;

[0020] S12, edge density threshold determination;

[0021] S13, community stability detection.

[0022] In step S11, the calculation of structural entropy is performed, specifically including but not limited to:

[0023] When the graph presents uniform community distribution (each community node proportion close to 1 / k), tends to the maximum value ; when the graph presents highly concentrated star structure (the proportion of a community close to 1, and the proportion of the remaining communities close to 0), tends to the minimum value 0. Wherein, represents the structural entropy value of the graph, represents the total number of community division, represents the proportion of the number of nodes in the community to the total number of nodes in the whole graph, and the specific form is as follows:

[0024] ;

[0025] Standardize the structural entropy to This index is equivalent to the Shannon-Pielou evenness widely used in ecology. This indicates the uniformity of community size distribution: the closer to 1, the closer the community size is to an equal proportion, the more crowded the overall visual perception, and the less distinct the hierarchy. Based on this cross-domain consensus, this system defaults to using... As the trigger interval for "excessively high uniformity", the corresponding unnormalized structural entropy threshold is:

[0026] ;

[0027] Therefore, a threshold is set. ,when If the complexity of the graph community structure is too high, the subgraph layering mechanism needs to be triggered.

[0028] In step S12, the edge density threshold is determined, which includes, but is not limited to:

[0029] use This indicates the tightness of the connectivity of the graph, i.e., edge density. When When =1, it is a complete graph (there is an edge between every pair of nodes). When = 0, it represents a discrete set of points, with the following specific form:

[0030] ;

[0031] Among them, | E | represents the actual number of edges in the graph, and |V| represents the total number of nodes in the graph. Extensive visualization and human factors research shows that node-connection graphs experience a sharp increase in edge intersections and a significant decrease in readability when locally dense, necessitating layering / aggregation to alleviate congestion. Practice shows that when the average number of edges per node within a local window is approximately 5-20, a clear inflection point often appears in visual congestion and interaction frame rate. Combining this human factors inflection point with the overall "extremely sparse, locally dense" distribution characteristics of large real-world graphs, the default threshold for local windows is set as follows:

[0032] ;

[0033] in, Indicates the size of the local window node, in The conversion is used as a monitoring indicator when > If the local connections in the graph are too dense, it is necessary to alleviate the rendering pressure by using layered subgraphs.

[0034] The step S13 includes, but is not limited to, community stability detection.

[0035] The community stability reflects the evolution speed of the graph structure over time, denoted by sigma, and the specific form is as follows:

[0036] ;

[0037] Where, Δ t represents the time window interval, and Δ C represents the community interface change amount of adjacent time windows, which can be calculated by the modularity difference:

[0038] ;

[0039] Where, is the adjacent matrix element, is the degree of node i, and m is the total number of edges, is the Kronecker function. The consensus clustering / partitioning stability research and the time network similarity research both use "the partitioning change is less than a small threshold (1-5%) and lasts for several times" to confirm the stable stage, which provides a reference for giving (i.e. the structural change rate per unit time 1-5%); when the community structure tends to be stable, the current hierarchical structure is frozen when the continuous three iterations .

[0040] In step S2, the super-aggregation node metadata encapsulation and cross-layer on-demand loading mechanism are completed, including:

[0041] S21, super-aggregation node metadata encapsulation;

[0042] S22, on-demand loading mechanism implementation.

[0043] In the step S21, the metadata is encapsulated into the super-aggregation node, including but not limited to:

[0044] Define the original graph , a plurality of subgraphs , and the boundary node set of the subgraph : ;

[0045] For any , define the internal degree , the external degree , and calculate the boundary score:

[0046] ;

[0047] The connection nodes of the subgraph and the external network are identified by topological division for dynamic boundary detection, and the connection nodes are denoted as With the minimum outer connection threshold If and , mark as "border candidate"; if and continue for several sampling periods, the border mark is revoked.

[0048] Real-time update of the boundary node state, establish subgraph jump index table , for each According to the target subgraph Aggregate outer connection edges, write / merge Record and initialize, used to store the relationship between each hyper-aggregation node-subgraph.

[0049] In the step S22, the on-demand loading mechanism is realized, specifically including but not limited to:

[0050] Define the necessary data of the target subgraph , wherein represents the target subgraph node ID set, represents the edge set compression set, represents the projection attribute matrix (only contains the attributes required for rendering, such as coordinates, color), and dynamically transitions from the hyper-aggregation node to the subgraph detail layer according to the distance of the viewpoint. Through this mechanism, the downlink load of the first interaction and each interaction is controlled at the MB level, which significantly reduces the transmission and analysis overhead compared with the MB-GB level of the full amount at one time; in the way of aggregation node pre-display and detail delayed expansion, the browser heap and video memory peak are stabilized in a controllable range, avoiding the freezing and crash caused by large volume JSON / buffer resident at one time; combined with the viewpoint-driven hierarchical switching, smooth drilling and stable frame rate are realized, ensuring the readability and interactivity of large-scale graphs.

[0051] In step S3, GPU-CUDA acceleration layout is introduced, including:

[0052] S31, the stress layout calculation of a single node is processed through CUDA parallel threads;

[0053] S32, dynamic load balancing and caching are adopted.

[0054] In the step S31, GPU-CUDA threads are called to process the stress of the node, specifically including but not limited to:

[0055] Define the stress of the node Each CUDA thread processes the stress calculation of a single node i, local density estimation , is the time step, and the specific form of the optimized speed update formula is as follows:

[0056] ;

[0057] ;

[0058] wherein represents the attractive force between node i and node j, represents the repulsive force between node i and node j, represents the Euclidean distance between node i and node j. By parallelizing the attractive / repulsive force summation and the density-weighted velocity update to CUDA, on the one hand, the memory access overhead is reduced by tiling with one node per thread and shared memory, and on the other hand, the repulsive force is approximated on the GPU in the Barnes-Hut (a hierarchical partitioning approximation algorithm originally used for celestial gravity and now also commonly used for approximating repulsive forces in force-directed layout) to reduce the cost, so that in the scale of 100,000 nodes and million-level edges, the time consumption per iteration is shortened by about 3-6 times compared with the traditional CPU force-directed layout, and the interactive frame rate or quasi-interactive experience is continuously maintained in the higher edge number interval.

[0059] In the step S32, a CUDA hierarchical thread model is enabled: thread-thread block-grid covers the entire calculation area, and by performing secondary division on high-load areas and in the manner of shared memory statistics block cache, the calculation tasks allocated to each CUDA core are relatively balanced.

[0060] Another object of the application is to provide a computer program product, the computer program instructions being stored on a computer readable storage medium and implementing the steps of the method when executed.

[0061] Another object of the application is to provide a computer device comprising:

[0062] a memory for storing computer programs / instructions;

[0063] a processor for implementing the steps of the above method when executing the computer programs / instructions.

[0064] Another object of the application is to provide a large-scale data graph rendering system comprising:

[0065] a graph data automatic layering unit for completing automatic layering processing of heterogeneous metadata;

[0066] a graph data calculation unit connected with the graph data preprocessing unit, for constructing graph data and layout calculation required for rendering graph;

[0067] a graph rendering unit connected with the graph data calculation unit, for rendering implementation of the graph;

[0068] a graph cache unit for dynamic caching according to the graph capacity.

[0069] a visualization unit configured to display the graph rendering result and the graph data related statistical result.

[0070] In combination with all the above technical solutions, the present application has the following advantages and positive effects:

[0071] First, in view of the technical problems existing in the prior art and the difficulty in solving the problems, the present application is closely combined with the technical solution to be protected, and the technical problems solved by the technical solution are analyzed in detail and profoundly, and some creative technical effects brought about after the problems are solved.

[0072] Second, the method reduces the transmission and rendering pressure of one-time loading by dynamic hierarchical on-demand loading, effectively reduces the front-end memory occupation and avoids browser crash.

[0073] Third, as the creative auxiliary evidence of the present application, it is also reflected in the following important aspects:

[0074] (1) Automatic hierarchical mechanism based on structural entropy: setting the data automatic hierarchical mechanism under the three-element standard of structural entropy-edge density-community stability.

[0075] (2) Super aggregation node-subgraph mode: by rendering a single aggregation node, the data transmission load is significantly reduced by loading sub-node data on demand.

[0076] (3) GPU CUDA layout acceleration calculation optimization: the speed update formula is optimized for the core mechanism of dynamically adjusting the position of the control node. BRIEF DESCRIPTION OF DRAWINGS

[0077] Figure 1 is a flow chart of the dynamic hierarchical rendering method for super large scale graph data according to the present application;

[0078] Figure 2 is a principle block diagram of the dynamic hierarchical rendering system for super large scale graph data according to the present application. DETAILED DESCRIPTION

[0079] The embodiments of the present application will be described below by specific examples, and those skilled in the art can easily understand other advantages and effects of the present application from the disclosed content of the present specification. Obviously, the described embodiments are part of the embodiments of the present application, but not all the embodiments. Based on the embodiments in the present application, all other embodiments obtained by those skilled in the art without creative labor fall within the scope of protection of the present application.

[0080] In addition, the technical features involved in different embodiments of the present application described below can be combined with each other as long as they do not conflict with each other.

[0081] The method for dynamic hierarchical rendering of super-large scale graph data provided by the embodiment of the application has the following innovative points: the method is based on a dynamic graph layering mechanism of structural entropy, a super-aggregated node-subgraph rendering architecture, and a multi-state coordination layout calculation strategy to improve the graph rendering efficiency.

[0082] Embodiment 1;

[0083] The method for dynamic hierarchical rendering of super-large scale graph data provided by the embodiment of the application has the following innovative points: the method is based on a dynamic graph layering mechanism of structural entropy, a super-aggregated node-subgraph rendering architecture, and a multi-state coordination layout calculation strategy to improve the graph rendering efficiency. Figure 1 and 2 as shown, which includes the following specific steps:

[0084] S1, constructing metadata dynamic layering rules through three dimensions of structural entropy, edge density and community stability, realizing automatic layering of the graph and a graph structure feedback mechanism, including:

[0085] S11, structural entropy calculation;

[0086] S12, edge density threshold determination;

[0087] S13, community stability detection.

[0088] Illustratively, in the step S11, the structural entropy is calculated, specifically including but not limited to:

[0089] When the graph presents a uniform community distribution (each community node accounts for close to 1 / k), tends to the maximum value ; when the graph presents a highly concentrated star structure (one community accounts for close to 1, and the rest of the communities account for close to 0), tends to the minimum value 0. Wherein, denotes the structural entropy value of the graph, denotes the total number of community divisions, denotes the proportion of the number of nodes in the community to the total number of nodes in the graph, and the specific form is as follows:

[0090] ;

[0091] The structural entropy is standardized as . The index is equivalent to the Shannon-Pielou evenness widely used in ecology, which represents the uniformity of community size distribution: the closer to 1, the closer the community size to equal proportion, the more crowded the global vision, and the less significant the hierarchy. Based on this cross-disciplinary consensus, the system defaults to as the trigger interval for "too high evenness"; the corresponding unnormalized structural entropy threshold is:

[0092] ;

[0093] Therefore, a threshold is set. ,when If the complexity of the graph community structure is too high, the subgraph layering mechanism needs to be triggered.

[0094] For example, in step S12, the edge density threshold is determined, which specifically includes, but is not limited to:

[0095] use This indicates the tightness of the connectivity of the graph, i.e., edge density. When When =1, it is a complete graph (there is an edge between every pair of nodes). When = 0, it represents a discrete set of points, with the following specific form:

[0096] ;

[0097] Among them, | E | represents the actual number of edges in the graph, and |V| represents the total number of nodes in the graph. Extensive visualization and human factors research shows that node-connection graphs experience a sharp increase in edge intersections and a significant decrease in readability when locally dense, necessitating layering / aggregation to alleviate congestion. Practice shows that when the average number of edges per node within a local window is approximately 5-20, a clear inflection point often appears in visual congestion and interaction frame rate. Combining this human factors inflection point with the overall "extremely sparse, locally dense" distribution characteristics of large real-world graphs, the default threshold for local windows is set as follows:

[0098] ;

[0099] in, Indicates the size of the local window node, in The conversion is used as a monitoring indicator when > If the local connections in the graph are too dense, it is necessary to alleviate the rendering pressure by using layered subgraphs.

[0100] For example, in step S13, the community stability detection specifically includes, but is not limited to:

[0101] Community stability reflects the rate of evolution of the graph structure over time, denoted by σ, and takes the following form:

[0102] ;

[0103] Where, Δ t Indicates the time window interval, Δ C The change in the community interface between adjacent time windows can be calculated using the modularity difference:

[0104] ;

[0105] in, For elements of the adjacency matrix, Let be the degree of node i, and m be the total number of edges. This refers to the Kronecker function. Both consensus clustering / segmentation stability studies and temporal network similarity studies use the condition that "segmentation changes are less than a small threshold (1%-5%) and persist for several cycles" to confirm a stable phase. This provides a basis for... (i.e., the rate of structural change per unit time) (1%-5%) provides a reproducible reference; when there are 3 consecutive iterations When the community structure is determined to be stable, the current hierarchical structure is frozen.

[0106] S2 completes the encapsulation of super-cluster node metadata and the cross-layer on-demand loading mechanism, including:

[0107] S21, Super Cluster Node Metadata Encapsulation;

[0108] S22, implemented using an on-demand loading mechanism.

[0109] For example, in step S21, the metadata is encapsulated into the super-cluster node, specifically including but not limited to:

[0110] Define the original graph Several subgraphs subgraph The set of boundary nodes: ;

[0111] For any Define internal degree , external degree Calculate the boundary ratio fraction:

[0112] ;

[0113] The connection nodes between the subgraph and the external network are identified through topological segmentation for dynamic boundary detection. Let... minimum outer threshold ,like and If it is, then it is marked as a "boundary candidate"; if If the boundary marker is not met for several consecutive sampling cycles, it will be removed.

[0114] Real-time updates of boundary node status and establishment of subgraph jump index table For each By target subgraph Aggregate outer edges, write / merge Record and initialize to store the relationships between each supernode and subgraph.

[0115] For example, in step S22, the on-demand loading mechanism is implemented, which specifically includes but is not limited to:

[0116] Define the necessary data of the target subgraph , wherein represents the set of target subgraph node IDs, represents the edge set compression set, represents the projection attribute matrix (only contains the attributes required for rendering, such as coordinates, color), which dynamically transitions from the super aggregation node to the subgraph detail layer according to the distance of the viewpoint. Through this mechanism, the downlink load of the first interaction and each interaction is controlled at the MB level, which is significantly lower than the MB-GB level of the full amount of data at one time, significantly reducing the transmission and analysis overhead; in the way of aggregation node pre-display and detail delayed expansion, the browser heap and video memory peak are stabilized in a controllable range, avoiding the freezing and crash caused by large volume JSON / buffer resident at one time; combined with the viewpoint-driven hierarchical switching, smooth drilling and stable frame rate are realized, ensuring the readability and interactivity of large-scale graphs.

[0117] S3, introduce GPU-CUDA accelerated layout, including:

[0118] S31, through CUDA parallel threads to process the stress layout calculation of a single node;

[0119] S32, dynamic load balancing and caching are adopted.

[0120] For example, in step S31, GPU-CUDA threads are called to process the stress of the node, which specifically includes but is not limited to:

[0121] Define the stress of the node Each CUDA thread processes the stress calculation of a single node i, local density estimation , is the time step, and the specific form of the optimized speed update formula is as follows:

[0122] ;

[0123] ;

[0124] , wherein represents the attractive force between node i and node j, represents the repulsive force between node i and node j, represents the Euclidean distance between node i and node j. By parallelizing the gravity / repulsion summation and the density-weighted velocity update to CUDA, on one hand, the memory access overhead is reduced by tiling with one thread per node and shared memory, on the other hand, the repulsion force is approximated on GPU by Barnes-Hut (a hierarchical partitioning approximation algorithm originally used for celestial gravity, now also commonly used in force-directed layout for approximating repulsion) to reduce the cost, so that in the scale of 100,000 nodes and million-level edges, the time consumption per iteration is reduced by about 3-6 times compared with the traditional CPU force-directed layout, and the interactive frame rate or quasi-interactive experience is continuously maintained in the higher edge number interval.

[0125] For example, in the step S32, a CUDA hierarchical thread model is enabled: thread-thread block-grid covers the entire calculation area, and by performing secondary partitioning on a high-load area and in a shared memory statistical block cache manner, the calculation tasks allocated to each CUDA core are relatively balanced.

[0126] Embodiment 2;

[0127] Embodiment 2 of the present application discloses a computer program product, the computer program instructions are stored on a computer readable storage medium, and when executed, the steps of the method are implemented.

[0128] Embodiment 3;

[0129] Embodiment 3 of the present application discloses a computer device, comprising:

[0130] a memory for storing computer programs / instructions;

[0131] a processor for executing the computer programs / instructions to implement the steps of the above method.

[0132] Embodiment 4;

[0133] Embodiment 4 of the present application discloses a large-scale data graph visualization analysis system, comprising:

[0134] a graph data automatic layering unit for completing automatic layering processing of heterogeneous metadata;

[0135] a graph data calculation unit connected with the graph data preprocessing unit, for constructing graph data and layout calculation required for rendering graph;

[0136] a graph rendering unit connected with the graph data calculation unit, for rendering and implementing the graph;

[0137] a graph cache unit for dynamically caching according to the graph capacity;

[0138] a visualization unit for displaying the graph rendering result and the graph data related statistical result.

[0139] In the atlas visualization analysis system, 1832944 entities and 119352557 relations composed of the entities are rendered according to the present application. A user can observe specific atlas details of any super cluster node through mouse click selection, scroll wheel zooming and the like. Meanwhile, the system also provides list query function of node and relation data, node search screening function, multi-selection node comparison details function and various layouts.

[0140] The above merely provides the preferred embodiments of the present application, but the protection scope of the present application is not limited thereto, and any modification, equivalent replacement and improvement within the technical range disclosed by the present application and within the spirit and principle of the present application should be encompassed within the protection scope of the present application.

Claims

1. A dynamic hierarchical rendering method for ultra-large scale graph data, characterized in that, The method dynamically layers massive heterogeneous multi-element data on the server based on multiple dimensions, renders with the structure of super-aggregated node-subgraph, simultaneously introduces GPU-CUDA parallel computing platform, dynamically balances load and cache layout calculation; the method comprises the following specific steps: S1, constructing metadata dynamic layering rules through three dimensions of structural entropy, edge density and community stability, realizing automatic layering of graph and graph structure feedback mechanism; In the step S1, the step of completing metadata dynamic layering comprises: S11, structural entropy calculation; S12, edge density threshold determination; S13, community stability detection; in the step S11, the calculation process of structural entropy is as follows: When the graph presents a uniform community distribution, tends to maximum When the graph presents a highly concentrated star structure, tends to minimum 0; wherein, represents the structural entropy value of the graph, represents the total number of community divisions, represents the proportion of the number of nodes in the community to the total number of nodes in the graph, and the specific form is as follows: ； The structural entropy is normalized as The threshold for the un-normalized structural entropy is: ； Setting threshold When the complexity of the community structure is too high, the subgraph layering mechanism is triggered. The specific process of the edge density threshold determination in step S12 is as follows: use to represent the connection tightness of the graph, i.e., the edge density, when =1 is a complete graph, =0 is a discrete point set, The expression of is as follows: ； wherein |E| denotes the actual number of edges in the graph and |V| denotes the total number of nodes in the graph, the default threshold value on the local window is set as: E wherein |E| denotes the actual number of edges in the graph and |V| denotes the total number of nodes in the graph, the default threshold value on the local window is set as: ； wherein, represents the local window node size, and is converted into a monitoring index, and when it is determined that the local connection of the atlas is too close, and the rendering pressure needs to be relieved by a hierarchical subgraph. The specific process of the community stability detection in step S13 is as follows: the community stability reflects the evolution speed of the graph structure over time, and is represented by , The specific form is as follows: ； wherein, denotes a time window interval, denotes a community interface change amount of adjacent time windows, which can be calculated by modularity difference ； wherein, is an adjacency matrix element, is a degree of a node is a degree of a node is a total number of edges, is a Kronecker function, i and j are both nodes; S2, super-aggregated encapsulation is performed on each layer of graph data to form a super-node+subgraph dual model structure, and the front end loads the subgraph of a specific super-node according to the viewing distance on demand; S3, dynamically dividing load to each CUDA core processing.

2. The method of claim 1, wherein, In the step S2, the specific process of completing super-aggregated node metadata encapsulation and cross-layer on-demand loading mechanism is as follows: Encapsulating metadata to super-nodes, including but not limited to: defining original graph , several sub-graphs , boundary node sets of sub-graphs : ; For any , define internal degree , external degree , compute boundary score: ； The connection nodes between the subgraph and the external network are identified through topological segmentation for dynamic boundary detection. Let... minimum outer threshold ,like and If it is, then it is marked as a "boundary candidate"; if If the criteria are not met for several consecutive sampling periods, the boundary marker is removed; the boundary node status is updated in real time, and a subgraph jump index table is established. For each By target subgraph Aggregate outer edges, write / merge Record and initialize to store the relationships between each supernode and subgraph; The specific process of implementing the on-demand loading mechanism is as follows: defining target subgraph necessary data wherein represents a target subgraph node ID set, represents an edge set compression set, represents a projection attribute matrix.

3. The method of claim 1, wherein, In the step S3, the process of introducing GPU-CUDA acceleration layout is as follows: Adopting dynamic load balancing and cache, processing the stress layout calculation of a single node through CUDA parallel thread, enabling CUDA hierarchical thread model: thread-thread block-grid covering the entire calculation area, through secondary division of high-load area, shared memory statistics block cache to ensure that the calculation task allocated to each CUDA core is relatively balanced; The specific process of calling GPU-CUDA thread to process node stress condition is as follows: Definition of node force Each CUDA thread handles the force calculation of a single node i, local density estimation , is the time step, and the optimized velocity update formula is as follows: ； ； wherein represents an attractive force between node i and node j, represents a repulsive force between node i and node j, represents the Euclidean distance between node i and node j.

4. A computer product comprising a program / instruction, characterized by The program / instruction is executed by the processor to realize the steps of the method of any one of claims 1 to 3.

5. An electronic device, comprising: Comprise: Memory for storing computer program / instruction; processor for realizing the steps of the method of any one of claims 1 to 3 when executing the computer program / instruction.

Images