Exposure-pull type load balancing method for GPU maximum cluster enumeration

Abstract

The invention relates to a GPU (Graphics Processing Unit) maximum clique enumeration-oriented exposure-pull type load balancing method, which comprises the following steps of: decomposing a search space of a maximum clique enumeration task into a plurality of sub-search trees, and creating a plurality of parallel working units on a GPU; in response to the fact that the working state of the working unit is a preset busy working state, setting an exposed node and executing a preset enumeration task until a preset descending condition is met, and switching to a preset idle working state; in response to the working state being a preset idle working state, traversing atomic counters of other working units and executing a preset pulling task; and in response to successful pulling, switching to a preset busy working state based on the exposed node information of the pulling working unit and the candidate branch index until the maximum clique enumeration task is completed. Therefore, the problems that in the related technology, due to the fact that frequent data transmission, task segmentation and synchronous operation are limited, calculation is interrupted, extra memory management overhead is needed for maintenance, and the calculation efficiency is limited are solved.

Description

Technical Field

[0001] This application relates to the fields of GPU high-performance computing, graph data mining and neuromorphic computing, and in particular to an exposure-pull load balancing method for GPU maximal clique enumeration. Background Technology

[0002] Maximal clique enumeration is a classic fundamental problem in graph theory and data mining, aiming to find all complete subgraphs in a given graph that cannot be further expanded. As a core task of graph analysis, this problem has long been a research hotspot in academia and industry, with wide applications in several key areas such as social network analysis, bioinformatics, computer vision, recommender systems, and neuromorphic computing. In neuromorphic computing, it can be used to identify tightly coupled clusters of neurons in neural networks, which are core structural units simulating the brain's information processing and cognitive functions. Taking social network analysis as an example, maximal clique enumeration can accurately identify the most closely related user groups in the network. With the explosive growth of graph data, especially neural network graphs in neuromorphic computing scenarios, which often have larger scales and more complex topologies, traditional CPU (Central Processing Unit) computing models are no longer sufficient to meet the performance requirements of maximal clique enumeration. GPUs (Graphics Processing Units), due to their massively parallel architecture, have become a key platform for accelerating this type of computation. However, maximal clique enumeration on GPUs faces severe load balancing challenges, primarily due to the extreme unevenness in the size of the search tree—some subtrees may contain millions of branches, while others have only a few nodes. This unevenness prevents the GPU's thousands of computing cores from being fully utilized, severely limiting computational efficiency.

[0003] In related technologies, a block processing strategy is adopted to divide graph data into multiple subgraphs and transmit them to the GPU for processing in sequence. An adaptive adjustment mechanism can also be introduced to dynamically adjust the size of task blocks according to GPU memory usage. mce-gpu (Maximal Clique Enumeration on GPU) adopts a device-based load balancing strategy. It achieves task scheduling by maintaining a global work list. Busy work units actively pause their current calculations and divide unprocessed tasks into blocks and put them into the work list for idle work units to obtain.

[0004] However, in related technologies, the block processing strategy relies on frequent data transmission between the host and the device, which generates huge communication overhead. The frequent pauses and task splitting operations of the working unit in the MCE-GPU solution seriously affect the continuity of computation, and the maintenance of the global data structure requires additional memory management overhead, which limits the overall computational efficiency of the system and urgently needs to be improved. Summary of the Invention

[0005] This application provides an exposure-pull load balancing method for GPU maximal clique enumeration to solve the problems in related technologies, such as the huge communication overhead caused by the block processing strategy relying on frequent data transmission between the host and the device, the interruption of computation caused by task partitioning and synchronization operations, which seriously affects the continuity of computation, and the need for additional memory management overhead for the maintenance of data structures, which leads to the limitation of the overall computational efficiency of the system.

[0006] The first aspect of this application provides an exposure-pull load balancing method for GPU maximal clique enumeration, comprising the following steps: decomposing the search space of the maximal clique enumeration task of the target graph into multiple sub-search trees, creating multiple parallel working units on the GPU, matching a corresponding sub-search tree and storage region from the multiple sub-search trees for each working unit, and activating each working unit; in response to the working state of the working unit being a preset busy working state, setting an exposure node based on the sub-search tree and the storage region, and executing a preset enumeration task based on the exposure node until a preset descent condition is met, and switching the working state of the current working unit to a preset idle working state; in response to the working state being the preset idle working state, traversing the atomic counters of other working units except the current working unit and executing a preset pull task; in response to a successful pull, constructing a new subtree root node based on the exposure node information and candidate branch index of the pull working unit to switch to the preset busy working state, and executing the preset enumeration task until the maximal clique enumeration task is completed.

[0007] Through the above-mentioned technical means, the embodiments of this application can decompose the maximal clique enumeration search space into multiple sub-search trees and process them in parallel by GPU working units. During the execution process, the working units dynamically expose search nodes and maintain atomic counters. Idle working units actively pull task branches through atomic operations, thereby achieving efficient load balancing without synchronization, eliminating the computational interruption and synchronization overhead of the working units, giving full play to the parallel computing potential of the GPU in large-scale maximal clique enumeration tasks, improving the utilization rate of GPU computing resources, reducing memory overhead and access latency, and possessing good versatility and scalability.

[0008] Optionally, in one embodiment of this application, the step of setting exposed nodes based on the sub-search tree and the storage area, and performing a preset enumeration task based on the exposed nodes until a preset descent condition is met, and switching the working state of the current working unit to a preset idle working state, includes: locating the shallowest node containing unexplored branches based on the depth-first search stack of the sub-search tree and the storage area, and setting it as an exposed node; calculating the number of candidate branches of the exposed node to update the atomic counter of the current working unit; checking the value of the atomic counter; in response to the value of the atomic counter being greater than zero, performing depth-first search enumeration based on the exposed node until the value of the atomic counter is zero; in response to the value of the atomic counter being zero, descending the exposed node along the depth-first search path towards deeper unexplored nodes until a preset descent condition is met, and switching the current working unit to a preset idle working state.

[0009] Through the above-mentioned technical means, the embodiments of this application can locate the shallowest node in the sub-search tree that contains unexplored branches as the exposed node by using the depth-first search stack. Based on the atomic counter value, the enumeration task is dynamically executed or the exposed node is triggered to descend to the deeper unexplored node until the condition is met and it switches to the idle state. Through the descending mechanism of the exposed node, the deep tasks of the sub-search tree can be fully explored, thereby ensuring that the busy unit always focuses on effective calculation during the task execution process, further improving the calculation efficiency of the working unit, and providing a more reasonable task partitioning basis for global load balancing.

[0010] Optionally, in one embodiment of this application, calculating the number of candidate branches of the exposed node to update the atomic counter of the current working unit includes: updating the atomic counter of the current working unit when the number of candidate branches of the exposed node is greater than a preset exposure threshold.

[0011] Through the above-mentioned technical means, the embodiments of this application can intelligently control the granularity of task segmentation by setting an exposure threshold, which avoids the proliferation of atomic operations caused by overly fine tasks, ensures the sufficiency and uniformity of load distribution, shortens the execution time of the critical path, and provides controllable load distribution granularity and good uniformity.

[0012] Optionally, in one embodiment of this application, the step of traversing the atomic counters of other working units besides the current working unit and executing a preset fetch task includes: traversing the atomic counters of the other working units; if the atomic counters of the other working units are positive, performing an atomic decrement operation to obtain the candidate branch index, and executing the preset fetch task.

[0013] Through the above technical means, the embodiments of this application can complete task retrieval by traversing the atomic counters of other working units and combining atomic decrement operations, thereby ensuring the thread safety of multi-threaded concurrent scheduling, avoiding the repeated allocation of tasks during the task retrieval process, and directly obtaining the branch index through atomic decrement, reducing the additional computational overhead of the scheduling process and improving the efficiency of task retrieval.

[0014] Optionally, in one embodiment of this application, activating each of the work units includes: activating the work unit and assigning an initial task, and switching the work state of the work unit that receives the initial task to a preset busy work state.

[0015] Through the above-mentioned technical means, the embodiments of this application can immediately allocate initial tasks after activating the GPU parallel work unit and simultaneously switch its working state to busy, thereby quickly starting the parallel computing process, shortening the overall task startup time, ensuring that global parallel computing has a high resource utilization rate, and laying a stable foundation for the dynamic balanced scheduling of subsequent tasks.

[0016] A second aspect of this application provides an exposure-pull load balancing device for GPU maximal clique enumeration, comprising: an activation module, configured to decompose the search space of the maximal clique enumeration task of the target graph into multiple sub-search trees, create multiple parallel working units on the GPU, match a corresponding sub-search tree and a storage region for each working unit from the multiple sub-search trees, and activate each working unit; an execution module, configured to, in response to the working state of the working unit being a preset busy working state, set an exposure node based on the sub-search tree and the storage region, and execute a preset enumeration task based on the exposure node until a preset descent condition is met, and switch the working state of the current working unit to a preset idle working state; a pull module, configured to, in response to the working state being the preset idle working state, traverse the atomic counters of other working units except the current working unit and execute a preset pull task; and a construction module, configured to, in response to successful pull, construct a new subtree root node based on the exposure node information and candidate branch index of the pulled working unit, switch to the preset busy working state, execute the preset enumeration task, and execute the preset enumeration task until the maximal clique enumeration task is completed.

[0017] Through the above-mentioned technical means, the embodiments of this application can decompose the maximal clique enumeration search space into multiple sub-search trees and process them in parallel by GPU working units. During the execution process, the working units dynamically expose search nodes and maintain atomic counters. Idle working units actively pull task branches through atomic operations, thereby achieving efficient load balancing without synchronization, eliminating the computational interruption and synchronization overhead of the working units, giving full play to the parallel computing potential of the GPU in large-scale maximal clique enumeration tasks, improving the utilization rate of GPU computing resources, reducing memory overhead and access latency, and possessing good versatility and scalability.

[0018] Optionally, in one embodiment of this application, the execution module includes: a setting unit, configured to locate the shallowest node containing unexplored branches based on the sub-search tree and the depth-first search stack of the storage area, and set it as an exposed node; calculate the number of candidate branches of the exposed node to update the atomic counter of the current working unit; and check the value of the atomic counter; a search unit, configured to perform a depth-first search enumeration based on the exposed node in response to the value of the atomic counter being greater than zero, until the value of the atomic counter is zero; and a descending unit, configured to descend the exposed node along the depth-first search path to deeper unexplored nodes in response to the value of the atomic counter being zero, until a preset descending condition is met, and switch the current working unit to a preset idle working state.

[0019] Through the above-mentioned technical means, the embodiments of this application can locate the shallowest node in the sub-search tree that contains unexplored branches as the exposed node by using the depth-first search stack. Based on the atomic counter value, the enumeration task is dynamically executed or the exposed node is triggered to descend to the deeper unexplored node until the condition is met and it switches to the idle state. Through the descending mechanism of the exposed node, the deep tasks of the sub-search tree can be fully explored, thereby ensuring that the busy unit always focuses on effective calculation during the task execution process, further improving the calculation efficiency of the working unit, and providing a more reasonable task partitioning basis for global load balancing.

[0020] Optionally, in one embodiment of this application, the setting unit includes: an update subunit, used to update the atomic counter of the current working unit when the number of candidate branches of the exposed node is greater than a preset exposure threshold.

[0021] Through the above-mentioned technical means, the embodiments of this application can intelligently control the granularity of task segmentation by setting an exposure threshold, which avoids the proliferation of atomic operations caused by overly fine tasks, ensures the sufficiency and uniformity of load distribution, shortens the execution time of the critical path, and provides controllable load distribution granularity and good uniformity.

[0022] Optionally, in one embodiment of this application, the pull module includes: an acquisition unit, configured to traverse the atomic counters of the other working units, and if the atomic counters of the other working units are positive, to perform an atomic decrement operation to obtain the candidate branch index and execute a preset pull task.

[0023] Through the above technical means, the embodiments of this application can complete task retrieval by traversing the atomic counters of other working units and combining atomic decrement operations, thereby ensuring the thread safety of multi-threaded concurrent scheduling, avoiding the repeated allocation of tasks during the task retrieval process, and directly obtaining the branch index through atomic decrement, reducing the additional computational overhead of the scheduling process and improving the efficiency of task retrieval.

[0024] Optionally, in one embodiment of this application, the activation module includes: an allocation unit, configured to activate the work unit and allocate an initial task, and switch the work state of the work unit that obtains the initial task to a preset busy work state.

[0025] Through the above-mentioned technical means, the embodiments of this application can immediately allocate initial tasks after activating the GPU parallel work unit and simultaneously switch its working state to busy, thereby quickly starting the parallel computing process, shortening the overall task startup time, ensuring that global parallel computing has a high resource utilization rate, and laying a stable foundation for the dynamic balanced scheduling of subsequent tasks.

[0026] A third aspect of this application provides an electronic device, including: a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the program to implement the exposure-pull load balancing method for GPU maximal clique enumeration as described in the above embodiments.

[0027] A fourth aspect of this application provides a non-volatile computer-readable storage medium storing a computer program that, when executed by a processor, implements the above-described exposure-pull load balancing method for GPU maximal clique enumeration.

[0028] A fifth aspect of this application provides a computer program product that stores a computer program that, when executed by a processor, implements the above-described exposure-pull load balancing method for GPU maximal clique enumeration.

[0029] This application's embodiments can decompose the maximal clique enumeration search space into multiple sub-search trees, which are then processed in parallel by GPU working units. During execution, each working unit dynamically exposes search nodes and maintains atomic counters. Idle working units actively pull task branches through atomic operations, thereby achieving efficient load balancing without synchronization. This eliminates computational interruptions and synchronization overhead for working units, fully leveraging the parallel computing potential of GPUs in large-scale maximal clique enumeration tasks, improving GPU computing resource utilization, reducing memory overhead and access latency, and exhibiting good versatility and scalability. Therefore, it solves the problems in related technologies, such as the huge communication overhead caused by frequent data transfers between the host and device due to the block processing strategy, computational interruptions caused by task partitioning and synchronization operations severely affecting computational continuity, and the limitation of overall system computational efficiency due to the additional memory management overhead required for data structure maintenance.

[0030] Additional aspects and advantages of this application will be set forth in part in the description which follows, and in part will be obvious from the description, or may be learned by practice of this application. Attached Figure Description

[0031] The above and / or additional aspects and advantages of this application will become apparent and readily understood from the following description of the embodiments taken in conjunction with the accompanying drawings, wherein: Figure 1 This is a flowchart of an exposure-pull load balancing method for GPU maximal clique enumeration provided according to an embodiment of this application; Figure 2 This is a flowchart of an exposure-pull load balancing method for GPU maximal clique enumeration according to an embodiment of this application; Figure 3 This is a schematic diagram of a load balancing system provided according to an embodiment of this application; Figure 4 Figure G is provided according to an embodiment of this application, and includes the four maximal cliques therein; Figure 5 A search tree generated corresponding to graph G according to an embodiment of this application; Figure 6 A schematic diagram illustrating the process of implementing an exposure-pull load balancing method for a subsearch tree with root node p according to an embodiment of this application; Figure 7 This is a schematic diagram of an exposed-pull load balancing device for GPU maximal clique enumeration provided according to an embodiment of this application; Figure 8 This is a schematic diagram of the structure of an electronic device provided according to an embodiment of this application.

[0032] Figure label: 10 - Exposure-pull load balancer for GPU maximal clique enumeration; 100 - Activation module; 200 - Execution module; 300 - Pull module; 400 - Construction module; 801 - Memory; 802 - Processor; 803 - Communication interface. Detailed Implementation

[0033] The embodiments of this application are described in detail below. Examples of these embodiments are shown in the accompanying drawings, wherein the same or similar reference numerals denote the same or similar elements or elements having the same or similar functions throughout. The embodiments described below with reference to the accompanying drawings are exemplary and intended to explain this application, and should not be construed as limiting this application.

[0034] The following describes an exposure-pull load balancing method for GPU maximal clique enumeration, based on embodiments of the present application, with reference to the accompanying drawings. Addressing the issues raised in the background section regarding the related technologies, where block processing strategies rely on frequent data transfers between the host and devices, resulting in significant communication overhead, task partitioning and synchronization operations cause computational interruptions, severely impacting computational continuity, and data structure maintenance requires additional memory management overhead, thus limiting overall system computational efficiency, this application provides an exposure-pull load balancing method for GPU maximal clique enumeration. In this method, the maximal clique enumeration search space can be decomposed into multiple sub-search trees and processed in parallel by GPU working units. During execution, the working units dynamically expose search nodes and maintain atomic counters. Idle working units actively pull task branches through atomic operations, thereby achieving efficient load balancing without synchronization. This eliminates computational interruptions and synchronization overhead for working units, fully leveraging the parallel computing potential of GPUs in large-scale maximal clique enumeration tasks, improving GPU computing resource utilization, reducing memory overhead and access latency, and exhibiting good versatility and scalability. This solves the problems in related technologies, such as the huge communication overhead caused by the block processing strategy relying on frequent data transmission between the host and the device, the interruption of computation caused by task partitioning and synchronization operations, which seriously affects the continuity of computation, and the limitation of the overall system computation efficiency due to the need for additional memory management overhead for data structure maintenance.

[0035] Specifically, Figure 1 This is a flowchart illustrating an exposure-pull load balancing method for GPU maximal clique enumeration provided in an embodiment of this application.

[0036] like Figure 1 As shown, this exposure-pull load balancing method for GPU maximal clique enumeration includes the following steps: In step S101, the search space of the maximal clique enumeration task of the target graph to be processed is decomposed into multiple sub-search trees, and multiple parallel working units are created on the GPU. For each working unit, the corresponding sub-search tree and storage area are matched from the multiple sub-search trees, and each working unit is activated.

[0037] It is understood that, in the embodiments of this application, the search space can be understood as the set of all possible search paths and candidate nodes when enumerating the maximal clique of the target graph to be processed; the sub-search tree can be generated by initializing the edges of the original graph and can perform enumeration calculations independently; the parallel working unit can be a thread bundle in the GPU, which is the smallest computing unit for performing the enumeration task; the storage area can be used to maintain its private depth-first search stack, local subgraph data, exposed node pointers, and atomic counters, etc.

[0038] In actual execution, the embodiments of this application can perform parallel processing architecture initialization, decompose the complete search space corresponding to the maximal clique enumeration task of the graph to be processed into multiple independent sub-search trees, create multiple parallel working units on the GPU, the number of which matches the hardware parallel capability of the GPU, and allocate the sub-search trees to each working unit, and allocate an independent storage area to each working unit to maintain its private depth-first search stack, local subgraph data, exposed node pointers and atomic counters.

[0039] The number of work units is configured as the product of the number of GPU streaming multiprocessors and the number of work units bound to each processor. Parallel work units are thread bundles in the GPU. Sub-search trees are generated by initializing the edges of the original graph. Atomic counters are maintained by atomic operation instructions supported by GPU hardware.

[0040] This application embodiment can split the global search space into independently computable sub-search trees and match tasks and storage resources for each parallel working unit to perform distributed initialization of maximal clique enumeration tasks and precise allocation of GPU resources, laying the foundation for subsequent parallel processing and dynamic load balancing. It allocates an independent storage area to each working unit, avoiding frequent access and competition for shared memory or global queues by multiple working units, reducing synchronization overhead and memory conflicts, and improving the stability and scalability of the system.

[0041] Optionally, in one embodiment of this application, activating each work unit includes: activating the work unit and assigning an initial task, and switching the work state of the work unit that has obtained the initial task to a preset busy work state.

[0042] It is understood that the initial task in the embodiments of this application can be understood as the initial calculation task corresponding to the sub-search tree matched by the work unit; the preset busy working state can be understood as the work unit being assigned a task. The preset busy working state can be set by those skilled in the art according to the actual situation, and no specific restrictions are made here.

[0043] In actual execution, the embodiments of this application can perform parallel processing architecture initialization, complete graph data loading and preprocessing, and then activate all work units. Each work unit obtains a unique initial task from the global task dispatcher through atomic operations (such as atomic increment).

[0044] Furthermore, in this embodiment, an edge in the graph can be used as a seed to construct the initial search node, because the number of edges is usually much greater than the number of vertices, which can provide higher initial parallelism. The working unit that obtains the task becomes the busy working unit and begins to perform a depth-first enumeration of its subtree.

[0045] Through the above-mentioned technical means, the embodiments of this application can immediately allocate initial tasks after activating the GPU parallel work unit and simultaneously switch its working state to busy, thereby quickly starting the parallel computing process, shortening the overall task startup time, ensuring that global parallel computing has a high resource utilization rate, and laying a stable foundation for the dynamic balanced scheduling of subsequent tasks.

[0046] In step S102, in response to the working state of the working unit being a preset busy working state, an exposed node is set based on the sub-search tree and the storage area, and a preset enumeration task is executed based on the exposed node until a preset descent condition is met, and the working state of the current working unit is switched to a preset idle working state.

[0047] It is understood that, in the embodiments of this application, the exposed node can be understood as the node with the shallowest depth containing unexplored branches located in the current depth-first search stack; the preset enumeration task can be understood as the depth-first search maximal clique enumeration process, and the preset enumeration task can be set by those skilled in the art according to the actual situation, without specific restrictions here; the preset descent condition can be understood as the condition that triggers the working unit to stop the current task and switch to an idle state, which can be that the exposed node pointer descends along the depth-first search path to a deeper unexplored node, and if it cannot descend, it switches to the preset idle working state, and the preset descent condition can be set by those skilled in the art according to the actual situation, without specific restrictions here.

[0048] In actual implementation, the embodiments of this application can respond to the working state of the working unit being a preset busy working state, and perform task loops based on the sub-search tree and storage area. While performing core enumeration calculations, the following operations are performed in a loop, with the principle of "dynamic exposure, uninterrupted calculation".

[0049] Set and update exposed nodes: Locate the shallowest node containing unexplored branches from the current depth-first search stack, set it as an exposed node, and calculate the number of its candidate branches to update the atomic counter corresponding to the work unit.

[0050] Check and process the counters: Check the value of the atomic counter. If the value is greater than zero, perform a parallel search; if the value is zero, either expose nodes in descending order or turn them idle.

[0051] Perform parallel search: Based on its currently exposed nodes, the work unit continues to perform a depth-first search enumeration. After completing the calculation for each node, it returns to the check counter and processes it.

[0052] Descend exposed nodes or switch to idle: Descend the exposed node pointer along the depth-first search path to deeper unexplored nodes; if the descent is successful, return to setting and updating exposed nodes; if the descent fails, it means the local task is complete and switch to the preset idle working state.

[0053] This application embodiment can trigger enumeration tasks based on busy working state, and provide high-quality task sources for idle units by exposing nodes until the conditions are met to switch states. Busy working units do not need to pause computing to actively split and hand over tasks. The filtering of the shallowest exposed nodes makes subsequent task splitting more scalable, avoiding the scheduling loss caused by frequent splitting of small tasks, thereby achieving efficient computing and accurate exposure of splittable tasks.

[0054] Optionally, in one embodiment of this application, based on the sub-search tree and storage area, exposed nodes are set, and a preset enumeration task is performed based on the exposed nodes until a preset descent condition is met, and the working state of the current working unit is switched to a preset idle working state. This includes: based on the depth-first search stack of the sub-search tree and storage area, locating the node with the shallowest depth and containing unexplored branches, and setting it as an exposed node; calculating the number of candidate branches of the exposed node to update the atomic counter of the current working unit; checking the value of the atomic counter; in response to the value of the atomic counter being greater than zero, performing depth-first search enumeration based on the exposed node until the value of the atomic counter is zero; in response to the value of the atomic counter being zero, descending the exposed node along the depth-first search path towards deeper unexplored nodes until the preset descent condition is met, and switching the current working unit to a preset idle working state.

[0055] It is understood that, in the embodiments of this application, the depth-first search stack can be understood as a stack structure that stores the current search path of the work unit, recording all path information from the root node of the sub-search tree to the current node, which is used to quickly locate unexplored nodes; the atomic counter can be understood as a thread-safe counter dedicated to each work unit, used to quantify the number of unexplored candidate branches of the exposed node, which is the core quantitative basis for task segmentation and retrieval; the candidate branch can be understood as the search path corresponding to the adjacent nodes that can be expanded from the exposed node to generate new candidate maximal cliques.

[0056] For example, a working unit locates the shallowest node containing unexplored branches from its depth-first search stack, sets it as the currently exposed node (by updating its pointer to point to that node), and calculates the number of remaining candidate branches for that node, writing this value to its counter via an atomic operation. Next, the working unit checks its counter. If the value is greater than zero, it continues depth-first search enumeration based on the current search stack, performing operations such as vertex expansion and pivot pruning. If the value is equal to zero, the working unit moves its pointer along the depth-first search path to deeper unexplored nodes. If the descent is successful, it returns to the step of updating the exposed node; if the descent is unsuccessful, meaning the local task is complete, the working unit enters an idle state.

[0057] In this embodiment, the shallowest node in the sub-search tree containing unexplored branches can be located using a depth-first search stack as the exposed node. Based on the atomic counter value, an enumeration task is dynamically executed or the exposed node is triggered to descend to a deeper unexplored node until the condition is met and it switches to an idle state. Through the descending mechanism of the exposed node, the deep tasks of the sub-search tree can be fully explored, thereby ensuring that busy units always focus on effective computation during task execution, further improving the computational efficiency of the work unit, and providing a more reasonable task partitioning basis for global load balancing.

[0058] Optionally, in one embodiment of this application, calculating the number of candidate branches of an exposed node to update the atomic counter of the current working unit includes: updating the atomic counter of the current working unit when the number of candidate branches of an exposed node is greater than a preset exposure threshold.

[0059] It is understood that the preset exposure threshold in the embodiments of this application can be understood as the critical value of the number of candidate branches. The preset exposure threshold can be 24. The preset exposure threshold can be set by those skilled in the art according to the actual situation, and no specific restrictions are made here.

[0060] In actual implementation, the embodiments of this application can set a preset exposure threshold. Only when the number of candidate branches of the exposed node is greater than the threshold will the atomic counter be updated to allow the task to be pulled. Otherwise, the task of the node will be handled by the working unit itself to balance the load granularity and synchronization overhead.

[0061] The embodiments of this application can intelligently control the granularity of task segmentation by setting an exposure threshold, which avoids the proliferation of atomic operations caused by overly fine tasks, ensures the sufficiency and uniformity of load distribution, shortens the execution time of the critical path, and provides controllable load distribution granularity and good uniformity.

[0062] In step S103, in response to the working state being a preset idle working state, the atomic counters of other working units except the current working unit are traversed and a preset pull task is executed.

[0063] It is understood that the preset idle working state in the embodiments of this application can be that the working unit has not obtained a task or has completed a task. The preset idle working state can be set by those skilled in the art according to the actual situation, and no specific restrictions are made here. The preset pull task can be understood as traversing and querying the atomic counters of all other working units. If a positive value is found, an atomic decrement operation is used to try to obtain a valid candidate branch index. The preset pull task can be set by those skilled in the art according to the actual situation, and no specific restrictions are made here.

[0064] In actual execution, this embodiment of the application can respond to a preset idle working state, where a work unit that has not received a task or has completed a task will cyclically traverse and query the counters of all other work units. When a counter is found to be positive, a preset fetch task is executed, attempting to obtain a valid candidate branch index through an atomic decrement operation. Once the index is obtained, the fetch task is successfully executed.

[0065] The embodiments of this application can trigger the traversal of atomic counters of other units based on the idle working state, accurately locate the tasks that can be pulled, and the idle working unit can autonomously pull the subtree to be processed through atomic operations, eliminating the synchronous waiting overhead of busy working units in traditional load balancing and improving the utilization of GPU computing resources.

[0066] Optionally, in one embodiment of this application, traversing the atomic counters of other working units besides the current working unit and executing a preset fetch task includes: traversing the atomic counters of other working units; if the atomic counters of other working units are positive, performing an atomic decrement operation to obtain the candidate branch index and executing the preset fetch task.

[0067] It is understood that the atomic decrement operation in this application embodiment can be understood as a thread-safe operation on the GPU side, used to obtain the candidate branch index while updating the workload of the original working unit; the candidate branch index can be understood as the position identifier of the pullable branch in the candidate branch list of exposed nodes, and the corresponding node information and search path can be quickly located through the index.

[0068] In actual execution, the embodiments of this application can perform a task retrieval loop for idle work units. Work units that have not obtained a task or have completed a task will traverse and query the atomic counters of all other work units. If a positive value is found, an atomic decrement operation will be used to attempt to obtain a valid candidate branch index.

[0069] This application embodiment can complete task retrieval by traversing the atomic counters of other work units and combining them with atomic decrement operations, thereby ensuring the thread safety of multi-threaded concurrent scheduling, avoiding duplicate task allocation during the task retrieval process, and directly obtaining the branch index through atomic decrement, reducing the additional computational overhead of the scheduling process and improving the efficiency of task retrieval.

[0070] In step S104, in response to a successful pull, a new subtree root node is constructed based on the exposed node information and candidate branch index of the pull work unit, so as to switch to a preset busy working state and execute a preset enumeration task until the maximal clique enumeration task is completed.

[0071] It is understood that in the embodiments of this application, successful retrieval can be understood as obtaining valid task information (candidate branch index, exposed node information) and completing the task ownership transfer; the new subtree root node can be understood as the root node of an independently executable subsearch tree constructed based on the retrieved task information, corresponding to the starting node of the retrieval branch.

[0072] In actual execution, this embodiment of the application can, in response to a successful task retrieval, construct a new subtree root node locally as its task based on the exposed node status (located by its pointer) and the obtained index of the retrieved work unit. A new search stack is generated locally based on the exposed node information, and a bitmap-style subgraph is shared with the source work unit. Subsequently, it is converted to a preset busy working state, added to computation, and executes a preset enumeration task. If no task is retrieved after traversing all units, the global termination judgment stage is entered: when all work units are in an idle state and none can retrieve a new task, the global maximal clique enumeration task is determined to be complete and the process exits.

[0073] The embodiments of this application can efficiently and load-balance the entire maximal clique enumeration task until all possible search paths have been explored. The "exposure-pull" mechanism enables efficient asynchronous collaboration between work units, avoiding the synchronous waiting overhead caused by busy work units having to actively split and hand over tasks.

[0074] Specifically, this application can be applied to social network analysis. In large social platforms such as Weibo and WeChat, users and their following relationships constitute a graph with an extremely large number of vertices and edges. Identifying "close-knit circles of friends" or "core interest communities" is essentially about mining maximal cliques within the graph. Traditional CPU computing methods are extremely time-consuming when processing networks with hundreds of millions of users and billions of relationships, making it difficult to meet real-time requirements. This application can load the entire social network graph onto GPU memory, utilizing thousands of parallel working units to simultaneously explore different community branches. The efficient load balancing mechanism of this application ensures that even for users with extremely wide connections (such as celebrities and influential figures, whose corresponding search subtrees are exceptionally large), their heavy computational tasks can be dynamically "exposed" and quickly "pulled" and distributed by numerous idle working units, thereby completing the mining of the entire platform's core communities in a very short time, providing computational speed for precise advertising, real-time public opinion monitoring, and community structure discovery.

[0075] This application can be applied to bioinformatics. In the field of biomolecular interactions, such as protein-protein interaction networks (PPIs), proteins can be considered vertices, and their interactions can be considered edges. A maximal clique often corresponds to a stable protein complex that works together to perform a specific function within the cell. Comprehensive enumeration of such complexes is crucial for understanding the mechanisms of life activities and discovering new drug targets. However, the biological networks generated by modern high-throughput technologies are massive and structurally complex, making the enumeration of all potential protein complexes a significant computational challenge. This application can place the entire protein interaction network on a GPU, which, through its unique expose-pull mechanism, can efficiently and in parallel traverse the space of all possible protein combinations. Its "synchronization-free" characteristic greatly reduces the idle waiting time during the search process, enabling researchers to complete computational tasks that previously took days or even weeks on a CPU in just a few hours, thus accelerating the progress of biomedical research.

[0076] This application's embodiments can be applied to computer vision. In complex visual scene understanding tasks, a graph-based model can be constructed, where key feature points or identified object instances in the image are used as vertices, and their spatial proximity or semantic associations are used as edges. In this visual graph, a maximal clique may correspond to a set of objects in the scene that are highly compatible both spatially and semantically, and co-occur frequently. This is crucial for accurately understanding the scene's composition. When dealing with high-resolution images or continuous video sequences, the constructed visual graph is enormous, requiring high real-time processing capabilities. This application's embodiments can enumerate maximal cliques on the visual graph on a GPU, enabling real-time or near-real-time identification of all stable object co-occurrence patterns in the scene. The superior load balancing capabilities of this application's embodiments ensure that visual patterns of different complexities and sizes (corresponding to search subtrees of vastly different sizes) can be processed synchronously and rapidly, providing technical support for applications with extremely demanding real-time requirements, such as autonomous driving and intelligent video surveillance.

[0077] Specifically, it can be combined with Figures 2 to 6 As shown, a specific embodiment is used to illustrate in detail the working principle of the exposure-pull load balancing method for GPU maximal clique enumeration in this application.

[0078] like Figure 2 As shown, embodiments of this application may include the following steps: Step 1: Initialize the parallel processing architecture. Decompose the complete search space corresponding to the maximal clique enumeration task into multiple independent sub-search trees. Create multiple parallel working units on the GPU and allocate an independent storage area for each working unit to maintain its private depth-first search stack, local subgraph data, exposed node pointers, and atomic counters.

[0079] Step 2: Busy work units execute task loops. Work units assigned tasks loop through the following sub-steps: Step 2.1: Set and update exposed nodes. Locate the shallowest node containing unexplored branches in the current depth-first search stack and set it as an exposed node. Calculate the number of its candidate branches to update the atomic counter of that work unit.

[0080] Step 2.2: Check the value of the atom counter. If the value is greater than zero, proceed to step 2.3. If the value is zero, proceed to step 2.4.

[0081] Step 2.3: Continue the depth-first search enumeration based on the currently exposed node, and return to step 2.2 after completion.

[0082] Step 2.4: Descend the exposed node pointer along the depth-first search path to deeper unexplored nodes. If the descent is successful, return to step 2.1. If the descent is unsuccessful, the working unit becomes idle and jumps to step 3.

[0083] Step 3: Idle work units execute a task fetching loop; work units that have not received any tasks or have completed their tasks execute the following sub-steps in a loop: Step 3.1: Traverse and query the atomic counters of all other work units. If a positive value is found, try to obtain a valid candidate branch index through atomic decrement operation. If successful, proceed to step 3.2; otherwise, proceed to step 4.

[0084] Step 3.2: Based on the exposed node status of the pulled work unit and the obtained candidate branch index, construct a new subtree root node independently as a local task, and then jump to step 2.

[0085] Step 4: When all work units are idle and cannot fetch new tasks, the global maximal clique enumeration task is considered complete.

[0086] like Figure 3 As shown, the embodiments of this application can provide a load balancing system that can perform load balancing on graph pattern mining tasks based on search tree traversal, including: a global read-only storage module, a global control module, and multiple parallel working units.

[0087] The global read-only storage module stores compressed data of the original graph. The graph data in the global read-only storage module is stored in a compressed sparse row format and is located in the GPU's global memory, which is shared by all working units for read-only access, ensuring data consistency and efficient utilization. The global control module is responsible for maintaining the system state and coordinating the task execution process. Its functions include preprocessing the input graph (e.g., performing degenerate sorting), loading the graph data onto the GPU, allocating initial task seeds to working units through a global atomic counter, and finally performing global termination judgment. Parallel working units are pre-allocated on the GPU, and their number is adapted to the number of streaming multiprocessors of the GPU.

[0088] Each work unit independently maintains its own state, including a local task store and a local control unit. The local task store stores the currently processed bitmap-like subgraph and the depth-first search stack; the local control unit manages the load balancing state of its unit, specifically maintaining two key variables: a pointer pointing to the search tree node that the work unit is currently willing to share with other idle units; and a counter, a variable manipulated by GPU atomic instructions, representing the number of remaining available task branches in the node pointed to by the pointer. The atomic counter, implemented using GPU hardware atomic instructions, indicates the number of remaining candidate branches for the currently exposed node.

[0089] Dynamic load balancing is achieved through an exposure-pull mechanism: Idle work units read the counters of other work units through atomic operations and attempt to pull tasks; after successfully pulling, a new search stack is generated locally based on the exposed node information, and a bitmap subgraph is shared with the source work unit, thereby switching to a busy state to continue executing the enumeration task.

[0090] Bitmap-based subgraphs maintain read-only shared characteristics during load balancing, avoiding data transfer overhead. The number of work units is configured as the product of the number of GPU streaming multiprocessors and the number of units bound per processor to achieve optimal utilization of hardware resources. Exposed nodes are only allowed to be pulled when their number of candidate branches exceeds a preset threshold, achieving an optimal balance between load granularity and synchronization overhead. Local subgraph data is represented using bitmap encoding, and during load balancing, the bitmap-encoded local subgraph is read-only shared between the source work unit and the work unit of the pull task.

[0091] like Figures 4 to 6 As shown, Figure 4 An example undirected graph G and its four maximal cliques are shown. Figure 5 This shows a partial search tree generated for the graph based on the Bron-Kerbosch algorithm. Figure 6 This application's embodiments specifically demonstrate the mechanism in... Figure 5The working process on the subtree with root node p is as follows: Initially, work unit 0 sets the root node p as an exposed node and initializes its counter to 2. Subsequently, idle work units 1 and 2 successively detect that the counter is positive and pull branches through atomic operations, constructing tasks for nodes k and j locally and starting independent computation. Crucially, during this period, work unit 0's own depth-first search process is not interrupted by these pull operations. After its counter drops to zero due to being pulled, work unit 0 decrements its pointer to a deeper node m in its search stack and updates the counter to 1. Finally, idle work unit 3 pulls the task at node m (node ​​l). This process clearly shows that the "expose-pull" mechanism of this application embodiment achieves efficient asynchronous collaboration between work units, avoiding the synchronous waiting overhead caused by busy work units needing to actively split and hand over tasks in traditional schemes.

[0092] The exposure-pull load balancing method for GPU maximal clique enumeration proposed in this application decomposes the maximal clique enumeration search space into multiple sub-search trees, which are then processed in parallel by GPU working units. During execution, each working unit dynamically exposes search nodes and maintains atomic counters. Idle working units actively pull task branches through atomic operations, thereby achieving efficient load balancing without synchronization. This eliminates computational interruptions and synchronization overhead for working units, fully leveraging the parallel computing potential of GPUs in large-scale maximal clique enumeration tasks, improving the utilization of GPU computing resources, reducing memory overhead and access latency, and exhibiting good versatility and scalability. This solves the problems in related technologies where the block processing strategy relies on frequent data transfer between the host and device, generating huge communication overhead; task partitioning and synchronization operations cause computational interruptions, severely affecting computational continuity; and data structure maintenance requires additional memory management overhead, resulting in limited overall system computational efficiency.

[0093] Next, referring to the accompanying drawings, an exposure-pull load balancing device for GPU maximal clique enumeration is described according to an embodiment of this application.

[0094] Figure 7 This is a schematic diagram of the exposed-pull load balancing device for GPU maximal clique enumeration according to an embodiment of this application.

[0095] like Figure 7 As shown, the exposure-pull load balancing device 10 for GPU maximum clique enumeration includes: an activation module 100, an execution module 200, a pull module 300, and a construction module 400.

[0096] The activation module 100 is used to decompose the search space of the maximal clique enumeration task of the target graph into multiple sub-search trees, create multiple parallel working units on the GPU, match the corresponding sub-search tree and storage area from multiple sub-search trees for each working unit, and activate each working unit.

[0097] The execution module 200 is used to respond to the working state of the working unit being a preset busy working state, set exposed nodes based on the sub-search tree and storage area, and execute preset enumeration tasks based on the exposed nodes until a preset descent condition is met, and switch the working state of the current working unit to a preset idle working state.

[0098] The pull module 300 is used to traverse the atomic counters of other working units except the current working unit and execute the preset pull task in response to the working state being a preset idle working state.

[0099] The construction module 400 is used to construct a new subtree root node in response to a successful pull, based on the exposed node information and candidate branch index of the pull work unit, to switch to the preset busy working state and execute the preset enumeration task until the maximal clique enumeration task is completed.

[0100] Optionally, in one embodiment of this application, the execution module 200 includes: a setting unit, a search unit, and a descending unit.

[0101] The setting unit is used to locate the shallowest node containing unexplored branches based on the depth-first search stack of the sub-search tree and storage area, and set it as an exposed node. The number of candidate branches of the exposed node is calculated to update the atomic counter of the current working unit, and the value of the atomic counter is checked. The search unit is used to perform a depth-first search enumeration based on the exposed nodes in response to the value of the atomic counter being greater than zero, until the value of the atomic counter is zero. The descent unit is used to respond to the value of the atomic counter being zero, and to descent the exposed node along the depth-first search path to the deeper unexplored node until the preset descent condition is met, and then switch the current working unit to the preset idle working state.

[0102] Optionally, in one embodiment of this application, the setting unit includes an update subunit.

[0103] Update sub-unit, used to update the atomic counter of the current working unit when the number of candidate branches of the exposed node is greater than the preset exposure threshold.

[0104] Optionally, in one embodiment of this application, the pull module 300 includes: an acquisition unit.

[0105] The acquisition unit is used to traverse the atomic counters of other working units. If the atomic counters of other working units are positive, an atomic decrement operation is performed to obtain the candidate branch index, and a preset fetch task is executed.

[0106] Optionally, in one embodiment of this application, the activation module 100 includes an allocation unit.

[0107] The allocation unit is used to activate the work unit and assign the initial task. The work unit that receives the initial task switches to the preset busy work state.

[0108] It should be noted that the foregoing explanation of the embodiment of the exposure-pull load balancing method for GPU maximal clique enumeration also applies to the exposure-pull load balancing device for GPU maximal clique enumeration in this embodiment, and will not be repeated here.

[0109] The exposure-pull load balancing device for GPU maximal clique enumeration proposed in this application can decompose the maximal clique enumeration search space into multiple sub-search trees, which are then processed in parallel by GPU working units. During execution, the working units dynamically expose search nodes and maintain atomic counters. Idle working units actively pull task branches through atomic operations, thereby achieving efficient load balancing without synchronization. This eliminates computational interruptions and synchronization overhead for working units, fully leveraging the parallel computing potential of GPUs in large-scale maximal clique enumeration tasks, improving the utilization of GPU computing resources, reducing memory overhead and access latency, and exhibiting good versatility and scalability. Therefore, it solves the problems in related technologies where the block processing strategy relies on frequent data transfer between the host and device, resulting in huge communication overhead; task partitioning and synchronization operations cause computational interruptions, severely affecting computational continuity; and the maintenance of data structures requires additional memory management overhead, leading to limited overall system computational efficiency.

[0110] Figure 8 A schematic diagram of the structure of an electronic device provided in an embodiment of this application. The electronic device may include: The memory 801, the processor 802, and the computer program stored on the memory 801 and capable of running on the processor 802.

[0111] When the processor 802 executes the program, it implements the exposure-pull load balancing method for GPU maximal clique enumeration provided in the above embodiments.

[0112] Furthermore, electronic devices also include: Communication interface 803 is used for communication between memory 801 and processor 802.

[0113] The memory 801 is used to store computer programs that can run on the processor 802.

[0114] The memory 801 may include high-speed RAM memory, and may also include non-volatile memory, such as at least one disk storage device.

[0115] If the memory 801, processor 802, and communication interface 803 are implemented independently, then the communication interface 803, memory 801, and processor 802 can be interconnected via a bus to complete communication between them. The bus can be an Industry Standard Architecture (ISA) bus, a Peripheral Component Interconnect (PCI) bus, or an Extended Industry Standard Architecture (EISA) bus, etc. Buses can be categorized into address buses, data buses, control buses, etc. For ease of representation, Figure 8 The bus is represented by a single thick line, but this does not mean that there is only one bus or one type of bus.

[0116] Optionally, in a specific implementation, if the memory 801, processor 802, and communication interface 803 are integrated on a single chip, then the memory 801, processor 802, and communication interface 803 can communicate with each other through an internal interface.

[0117] The processor 802 may be a central processing unit (CPU), an application specific integrated circuit (ASIC), or one or more integrated circuits configured to implement the embodiments of this application.

[0118] This application also provides a non-volatile computer-readable storage medium storing a computer program that, when executed by a processor, implements the above-described exposure-pull load balancing method for GPU maximal clique enumeration.

[0119] This application also provides a computer program product on which a computer program is stored, which, when executed by a processor, implements the above-described exposure-pull load balancing method for GPU maximal clique enumeration.

[0120] In the description of this specification, the references to terms such as "one embodiment," "some embodiments," "example," "specific example," or "some examples," etc., indicate that a specific feature, structure, material, or characteristic described in connection with that embodiment or example is included in at least one embodiment or example of this application. In this specification, the illustrative expressions of the above terms do not necessarily refer to the same embodiment or example. Furthermore, the specific features, structures, materials, or characteristics described may be combined in any suitable manner in one or more embodiments or examples. Moreover, without contradiction, those skilled in the art can combine and integrate the different embodiments or examples described in this specification, as well as the features of different embodiments or examples.

[0121] Furthermore, the terms "first" and "second" are used for descriptive purposes only and should not be construed as indicating or implying relative importance or implicitly specifying the number of technical features indicated. Thus, a feature defined as "first" or "second" may explicitly or implicitly include at least one of that feature. In the description of this application, "N" means at least two, such as two, three, etc., unless otherwise explicitly specified.

[0122] Any process or method described in the flowchart or otherwise herein can be understood as representing a module, segment, or portion of code comprising one or N executable instructions for implementing custom logic functions or processes, and the scope of the preferred embodiments of this application includes additional implementations in which functions may be performed not in the order shown or discussed, including substantially simultaneously or in reverse order depending on the functions involved, as should be understood by those skilled in the art to which embodiments of this application pertain.

[0123] The logic and / or steps represented in the flowchart or otherwise described herein, for example, can be considered as a sequenced list of executable instructions for implementing logical functions, and can be embodied in any computer-readable medium for use by, or in conjunction with, an instruction execution system, apparatus, or device (such as a computer-based system, a processor-included system, or other system that can fetch and execute instructions from, an instruction execution system, apparatus, or device). For the purposes of this specification, "computer-readable medium" can be any means that can contain, store, communicate, propagate, or transmit programs for use by, or in conjunction with, an instruction execution system, apparatus, or device. More specific examples (a non-exhaustive list) of computer-readable media include: an electrical connection having one or more wires (electronic device), a portable computer disk drive (magnetic device), random access memory (RAM), read-only memory (ROM), erasable and editable read-only memory (EPROM or flash memory), fiber optic devices, and portable optical disc read-only memory (CDROM). Alternatively, the computer-readable medium may be paper or other suitable media on which the program can be printed, since the program can be obtained electronically by optically scanning the paper or other medium, followed by editing, interpreting, or otherwise processing as necessary, and then stored in a computer memory.

[0124] It should be understood that the various parts of this application can be implemented using hardware, software, firmware, or a combination thereof. In the above embodiments, the N steps or methods can be implemented using software or firmware stored in memory and executed by a suitable instruction execution system. If implemented in hardware, as in another embodiment, it can be implemented using any one or more of the following techniques known in the art: discrete logic circuits having logic gates for implementing logical functions on data signals, application-specific integrated circuits (ASICs) having suitable combinational logic gates, programmable gate arrays (PGAs), field-programmable gate arrays (FPGAs), etc.

[0125] Those skilled in the art will understand that all or part of the steps of the methods in the above embodiments can be implemented by a program instructing related hardware. The program can be stored in a computer-readable storage medium, and when executed, the program includes one or a combination of the steps of the method embodiments.

[0126] Furthermore, the functional units in the various embodiments of this application can be integrated into a processing module, or each unit can exist physically separately, or two or more units can be integrated into a module. The integrated module can be implemented in hardware or as a software functional module. If the integrated module is implemented as a software functional module and sold or used as an independent product, it can also be stored in a computer-readable storage medium.

[0127] The storage medium mentioned above can be a read-only memory, a disk, or an optical disk, etc. Although embodiments of this application have been shown and described above, it is understood that the above embodiments are exemplary and should not be construed as limiting this application. Those skilled in the art can make changes, modifications, substitutions, and variations to the above embodiments within the scope of this application.

Claims

1. An exposure-pull load balancing method for GPU maximal clique enumeration, characterized in that, Includes the following steps: The search space of the maximal clique enumeration task of the target graph to be processed is decomposed into multiple sub-search trees, and multiple parallel working units are created on the GPU. For each working unit, the corresponding sub-search tree and storage area are matched from the multiple sub-search trees, and each working unit is activated. In response to the working state of the working unit being a preset busy working state, an exposed node is set based on the sub-search tree and the storage area, and a preset enumeration task is executed based on the exposed node until a preset descent condition is met, and the working state of the current working unit is switched to a preset idle working state. In response to the working state being the preset idle working state, the atomic counters of other working units except the current working unit are traversed and a preset fetch task is executed; In response to a successful pull, a new subtree root node is constructed based on the exposed node information and candidate branch index of the pull work unit, to switch to the preset busy working state, and execute the preset enumeration task until the maximal clique enumeration task is completed.

2. The method according to claim 1, characterized in that, The step of setting exposed nodes based on the sub-search tree and the storage area, and executing a preset enumeration task based on the exposed nodes until a preset descent condition is met, and then switching the working state of the current working unit to a preset idle working state, includes: Based on the sub-search tree and the depth-first search stack of the storage area, locate the node with the shallowest depth and containing unexplored branches, and set it as an exposed node. Calculate the number of candidate branches of the exposed node to update the atomic counter of the current working unit, and check the value of the atomic counter. In response to the atomic counter value being greater than zero, a depth-first search enumeration is performed based on the exposed node until the atomic counter value is zero; In response to the value of the atomic counter being zero, the exposed node is decremented along the depth-first search path to deeper unexplored nodes until a preset decrementing condition is met, and the current working unit is switched to a preset idle working state.

3. The method according to claim 2, characterized in that, The step of calculating the number of candidate branches of the exposed node to update the atomic counter of the current working unit includes: When the number of candidate branches of the exposed node is greater than the preset exposure threshold, the atomic counter of the current working unit is updated.

4. The method according to claim 1, characterized in that, The step of traversing the atomic counters of all working units except the current working unit and executing the preset fetch task includes: The atomic counters of the other working units are traversed. If the atomic counters of the other working units are positive, an atomic decrement operation is performed to obtain the candidate branch index, and a preset fetch task is executed.

5. The method according to claim 1, characterized in that, Activating each of the work units includes: The work unit is activated and an initial task is assigned. The work status of the work unit that receives the initial task is switched to a preset busy work status.

6. An exposure-pull load balancing device for GPU maximal clique enumeration, characterized in that, include: An activation module is used to decompose the search space of the maximal clique enumeration task of the target graph into multiple sub-search trees, create multiple parallel working units on the GPU, match the corresponding sub-search tree and storage area from the multiple sub-search trees for each working unit, and activate each working unit. The execution module is used to respond to the working state of the working unit being a preset busy working state, set an exposed node based on the sub-search tree and the storage area, and execute a preset enumeration task based on the exposed node until a preset descent condition is met, and switch the working state of the current working unit to a preset idle working state. The pull module is used to respond to the working state being the preset idle working state, traverse the atomic counters of other working units except the current working unit and execute the preset pull task; A construction module is used to construct a new subtree root node in response to a successful pull, based on the exposed node information and candidate branch index of the pull work unit, to switch to the preset busy working state and execute the preset enumeration task until the maximal clique enumeration task is completed.

7. The apparatus according to claim 6, characterized in that, The execution module includes: The setting unit is used to locate the shallowest node containing unexplored branches based on the subsearch tree and the depth-first search stack of the storage area, and set it as an exposed node; calculate the number of candidate branches of the exposed node to update the atomic counter of the current working unit; and check the value of the atomic counter. The search unit is configured to perform a depth-first search enumeration based on the exposed nodes in response to the value of the atomic counter being greater than zero, until the value of the atomic counter is zero. A descent unit is used to respond to the value of the atomic counter being zero by descenting the exposed node along the depth-first search path to the deeper unexplored node until a preset descent condition is met, and then switching the current working unit to a preset idle working state.

8. An electronic device, characterized in that, include: The memory, the processor, and the computer program stored in the memory and capable of running on the processor, wherein the processor executes the program to implement the exposure-pull load balancing method for GPU maximal clique enumeration as described in any one of claims 1-5.

9. A non-volatile computer-readable storage medium having a computer program stored thereon, characterized in that, The program is executed by the processor to implement the exposure-pull load balancing method for GPU maximal clique enumeration as described in any one of claims 1-5.

10. A computer program product, comprising a computer program, characterized in that, The computer program is executed to implement the exposure-pull load balancing method for GPU maximal clique enumeration as described in any one of claims 1-5.

Images