Distributed edge computing method for data communication

Abstract

The invention belongs to the technical field of edge computing, and particularly relates to a distributed edge computing method for data communication, which comprises the following steps of: acquiring task information of terminal equipment and computing power data of edge nodes to create a multi-objective optimization model and a mathematical model framework thereof, and acquiring an optimal solution meeting an optimization objective and a constraint condition; the method comprises the following steps: constructing a distributed computing network architecture, decomposing a computing task into N heterogeneous sub-tasks, performing sub-task granularity optimization, setting priorities for the optimized sub-tasks, and pre-allocating initial edge nodes; based on a node credit evaluation mechanism of a block chain, task allocation weights are dynamically adjusted, and dynamic migration of sub-tasks between edge nodes is realized through local edge node decision and central node arbitration. And each edge node sends the preprocessed data needing deep processing to the center node for deep processing and then returns the preprocessed data to the edge node.

Description

Technical Field

[0001] The present invention belongs to the technical field of server heat dissipation, and in particular relates to a distributed edge computing method for data communication. Background Art

[0002] In today's digital age, data traffic is exploding. The widespread adoption of emerging technologies such as the Internet of Things, artificial intelligence, and big data has led to a dramatic increase in the amount of data generated by terminal devices. Traditional cloud computing, which transmits all data to remote data centers for processing, faces challenges such as high network latency, bandwidth constraints, high data transmission costs, and privacy and security risks. This makes it difficult to meet the demands of real-time, compute-intensive applications such as autonomous driving, industrial automation control, and real-time video processing.

[0003] Edge computing, an emerging computing paradigm, deploys computing resources at the edge of the network, close to data sources, offloading some data processing tasks from the cloud to edge nodes. This effectively reduces data transmission latency, alleviates network bandwidth pressure, and improves the privacy and security of data processing. However, existing edge computing technologies still have many shortcomings in task allocation, resource utilization, and network architecture. For example, in task allocation, there is a lack of efficient multi-objective optimization mechanisms, making it difficult to simultaneously consider multiple key metrics such as task processing latency, resource utilization, and energy consumption. Resource utilization is also hindered by a lack of efficient resource scheduling and allocation based on the dynamic state of terminal devices and edge nodes, resulting in frequent resource waste or resource shortages. Traditional edge computing network architectures lack flexibility and adaptability, making them difficult to adapt to complex and changing network environments and diverse application requirements. Furthermore, when edge nodes fail or go offline, existing technologies cannot effectively ensure computing relay and data processing continuity, impacting the stability and reliability of the entire system.

[0004] With the development of distributed computing technology, distributed edge computing has gradually become a research hotspot, but how to build an efficient, reliable and secure distributed edge computing network and realize the reasonable allocation and dynamic scheduling of computing tasks is still a key issue that needs to be solved urgently. Summary of the Invention

[0005] The purpose of the present invention is to provide a distributed edge computing method for data communication, so as to build an efficient, reliable and secure distributed edge computing network and realize the reasonable allocation and dynamic scheduling of computing tasks.

[0006] In order to solve the above technical problems, the technical solutions adopted by the present invention are as follows: A distributed edge computing method for data communication, comprising the following steps: S1: Collect task information of each terminal device and computing power data of edge nodes in real time, and create a multi-objective optimization model based on the task information of each terminal device and computing power data of edge nodes; S2: Setting the optimization objectives and constraints of the multi-objective optimization model, building a mathematical model framework for the multi-objective optimization model, and solving the multi-objective optimization model using a specified optimization algorithm to obtain an optimal solution that meets the optimization objectives and constraints; S3: Dynamically build a distributed computing network architecture in real time based on the optimal solution, determine the role and task allocation relationship of each edge node in the network, and build a distributed edge computing network consisting of multiple edge nodes and a central node; S4: Based on the computing power status of the terminal device and network latency, the computing task is decomposed into N heterogeneous subtasks and the subtask granularity is optimized. Priorities are set for the optimized subtasks and initial edge nodes are pre-assigned. S5: Based on the blockchain node credit evaluation mechanism, task allocation weights are dynamically adjusted. At the same time, subtasks are dynamically migrated between edge nodes through local edge node decision-making and central node arbitration. S6: When the edge node is offline, a preset diffusion scheme is used to perform computational relay to preprocess all subtasks. Each edge node sends the preprocessed data that needs to be deeply processed to the central node for deep processing before returning it to the edge node. S7: The edge node directly returns the pre-processed data that does not require deep processing to the terminal device, and returns the deeply processed data to the terminal device.

[0007] Preferably, the specific process of setting the optimization objectives and constraints of the multi-objective optimization model and constructing the mathematical model framework of the multi-objective optimization model in step S2 is as follows: S21: Setting the optimization objectives of the multi-objective optimization model includes minimizing task processing delay, maximizing resource utilization, and minimizing energy consumption; S22: Setting constraints for the multi-objective optimization model includes computing resource upper limit constraints, network bandwidth limit constraints, and task data security transmission requirement constraints; S23: Constructing a mathematical model framework of a multi-objective optimization model based on the optimization objectives and constraints, defining decision variables of the mathematical model framework, and constructing an objective function and its constraints.

[0008] Preferably, the detailed execution process of step S23 is as follows: S231: The decision variables of the mathematical model framework of the multi-objective optimization model are defined as x ij , when the task i ( i =1,2,⋯, n) assigned to edge nodes j ( j =1,2,⋯, m )hour, x ij =1; otherwise x ij =0, let y ij is a continuous variable, indicating the task i Assign to edge nodes j The amount of computing resources used when S232: Objective function of mathematical model framework for constructing multi-objective optimization model: ; ; ; Among them, Z1 is the objective function of minimizing task processing delay, Z2 is the objective function of maximizing resource utilization, and Z3 is the objective function of minimizing energy consumption. For the task i At the edge node j The waiting time in queues, For the task i Transmitted from terminal devices to edge nodes j time, For the task i At the edge node j The actual computation processing time on α j 、 β j 、 γ j These are the weight coefficients of CPU, storage, and network resource utilization respectively; R j c 、 R j s 、 R j b Edge nodes j The total amount of CPU, storage, and network resources; s ij 、 b ij Respectively for tasks i The amount of storage resources and network bandwidth occupied on edge node j, e j ( y ij ) is an edge node j Processing tasks iBased on the amount of computing resources occupied y ij Energy consumption function; S233: Constraints for establishing the mathematical model framework of the target optimization model: Computing resource upper limit constraints: ; Network bandwidth limitations and constraints: ; Task data security transmission requirements and constraints: ; Among them, Security i , j ) indicates a task i At the edge node j The safety standard function that is satisfied during processing returns 1 if satisfied, otherwise returns 0; Task assignment uniqueness constraint: .

[0009] Preferably, in step S2, the specific process of using a specified optimization algorithm to solve the multi-objective optimization model and obtain the optimal solution that meets the optimization objectives and constraints is as follows: S24: Use matrix coding to represent each task as [ x 1, x 2,..., x n ] T ,in x i Corresponding edge node i The task allocation ratio is improved by introducing a dynamic gene length mechanism to adapt to topological changes with variable node numbers; S25: Generate an initial solution set based on the node capability graph to ensure that: , and 0≤ x j ≤ C i max ; C i max For nodes i Maximum load factor; S26: Adopt the ε-dominance screening method to retain high-quality solutions with a spacing greater than the threshold ε, establish a solution set archive, record the evolution trajectory of the historical optimal solution, and calculate the 95% confidence interval of the target value through Bootstrap sampling. Set the key perturbation parameters to verify the robustness of the optimal solution.

[0010] Preferably, in step S3, a distributed computing network architecture is dynamically constructed in real time based on the optimal solution, the role and task allocation relationship of each edge node in the network is determined, and the specific process of constructing a distributed edge computing network consisting of multiple edge nodes and one central node is as follows: S31: Deploy a central node with global scheduling capabilities based on node performance, load the dynamic game algorithm framework, and initialize the resource database and topology map; S32: The edge node reports the metadata of computing power, storage, and location to the central node through a lightweight protocol to form an initial resource pool; S33: Based on real-time load and task requirements, the central node calculates the optimal role of each node through the potential game algorithm, including data preprocessing nodes, model inference nodes, and relay nodes, and periodically evaluates the node status and sets the node role reallocation trigger conditions. When the reallocation trigger conditions are met, role reallocation is triggered.

[0011] Preferably, in step S4, the computing task is decomposed into N heterogeneous subtasks and the subtask granularity is optimized according to the computing power status of the terminal device and the network delay. The specific process of setting priorities for the optimized subtasks and pre-allocating initial edge nodes is as follows: S41: Use performance probes to collect node CPU / GPU computing power, memory, and network latency data to build a resource feature matrix. S42: Optimizing the subtask granularity using a genetic algorithm based on the resource feature matrix and task type to ensure that the computing task granularity matches the node computing power; S43: Identify critical subtasks based on the task dependency graph and assign them the highest priority to reduce overall latency. Dynamically adjust priority weights based on business SLA requirements. Use the Hungarian algorithm to match the remaining computing power of edge nodes with the network topology based on subtask resource requirements, prioritize low-latency nodes, pre-allocate backup nodes for high-priority subtasks, and implement fault switching within seconds through heartbeat detection.

[0012] Preferably, the specific process of optimizing the subtask granularity using a genetic algorithm based on the resource feature matrix and task type in step S42 is as follows: S421: defining a subtask granularity coding range based on computation intensiveness or IO intensiveness; S422: Encode the subtask granularity into chromosomes and use real number encoding to adapt to continuous parameter optimization. Take task processing latency, resource utilization, and energy consumption as optimization targets, dynamically adjust weight coefficients, and iterate and optimize to converge to the optimal solution through arithmetic crossover and elite retention strategies. S423: Match the node with the most suitable computing power in the resource matrix according to the optimized subtask requirements.

[0013] Preferably, in step S5, the node credit evaluation mechanism based on the blockchain dynamically adjusts the task allocation weight, and the specific process of dynamically migrating subtasks between edge nodes through local edge node decision-making and central node arbitration is as follows: S51: Build a dynamic credit scoring model by recording the node's historical task completion rate, response delay, and computing power stability data through the blockchain; S52: A fuzzy logic algorithm is used to map credit scores to task allocation weights, with high-credit nodes receiving key subtasks first. S53: The local node triggers a subtask migration request based on real-time load and credit thresholds. The rationality of the migration is verified through smart contracts to prevent malicious node manipulation. The arbitration results are stored on the chain. S54: Based on the Hungarian algorithm, the migration task is matched with the computing power and network status of the target node. During the migration process, the task context is synchronized through a lightweight blockchain to ensure consistency.

[0014] Preferably, the specific process of step S6 is as follows: S61: Detect node status at specified intervals through the 5G MEC network. If a node exceeds a specified number of times, it is considered offline. Then, based on the preset topology, the subtasks of the offline node are spread to adjacent designated edge nodes according to priority to ensure preprocessing continuity. S62: Online nodes perform data preprocessing, compressing the data to a specified ratio of the original data, and annotating complex tasks that require central processing through metadata, along with a description of the node's computing power requirements. S63: Low-latency fiber channels are used to transmit labeled data, and the central GPU cluster completes AI reasoning / large-scale computing. The processing results are verified by the edge gateway and then distributed to the original edge node.

[0015] The beneficial effects of the present invention include: The distributed edge computing method for data communication provided by the present invention creates a multi-objective optimization model by real-time collection of terminal device task information and edge node computing power data, and sets optimization goals such as minimizing task processing delay, maximizing resource utilization, minimizing energy consumption, and multiple constraints. It is combined with a specified optimization algorithm to solve the optimal solution, and can accurately and reasonably allocate and schedule tasks. Compared with traditional methods, it greatly reduces task processing delay, improves task execution efficiency, reduces unnecessary energy consumption, and improves overall resource utilization. In actual application scenarios, for tasks such as autonomous driving and industrial automation control with high real-time requirements, it can ensure that data is processed in a timely manner to ensure the stable operation and security of the system. In terms of network architecture construction and management, a distributed computing network architecture is dynamically constructed in real time based on the optimal solution to determine the role of each edge node and the relationship between task allocation. The central node uses a dynamic game algorithm framework and combines the metadata reported by the edge nodes to form a resource pool, and calculates the optimal role of the node through the potential game algorithm, so that the network architecture can be flexibly adjusted according to real-time load and task requirements, significantly enhancing the adaptability and flexibility of the network. It can effectively cope with complex and changing network environments and diverse application requirements. Compared with traditional fixed-architecture edge computing networks, it can better meet the computing needs in different scenarios and improve the overall performance and reliability of the network. In the subtask processing and allocation stage, computing tasks are decomposed and subtask granularity is optimized based on the computing power status of the terminal device and network delay. Genetic algorithms are used to optimize the subtask granularity to match it with the node computing power. Priorities and pre-allocated nodes are set in combination with the task dependency graph and business SLA requirements. This ensures that computing tasks can be efficiently executed on the most appropriate nodes, reduces mutual interference between tasks, and further improves the efficiency and quality of task processing. It is especially suitable for complex computing-intensive or IO-intensive task scenarios. In terms of dynamic task management and node failure response, a blockchain-based node credit assessment mechanism dynamically adjusts task allocation weights. Dynamic subtask migration is achieved through local edge node decision-making and central node arbitration. This ensures the fairness and rationality of task allocation while improving system security and stability, preventing manipulation by malicious nodes. When an edge node goes offline, a pre-set diffusion scheme implements computational relay and data preprocessing. The central node performs in-depth processing of specific data, ensuring the successful completion of all subtasks and maintaining data processing continuity. Compared to existing technologies, this significantly improves the system's fault tolerance and reliability in the face of node failures. BRIEF DESCRIPTION OF THE DRAWINGS

[0016] Figure 1 Schematic diagram of the distributed edge computing method for data communication of the present invention.

[0017] Figure 2A schematic diagram of the flow chart of the mathematical model framework for constructing a multi-objective optimization model for the present invention.

[0018] Figure 3 Schematic diagram of the distributed computing network architecture of the present invention. DETAILED DESCRIPTION

[0019] The following is combined with Figures 1 to 3 The present invention is described in further detail: Example 1 See attached Figure 1 As shown, a distributed edge computing method for data communication includes the following steps: S1: Real-time collection of task information of each terminal device and computing power data of edge nodes, and creation of a multi-objective optimization model based on the task information of each terminal device and the computing power data of edge nodes. The distributed computing network architecture of the present invention is not fixed, but is dynamically constructed based on the real-time task information of each terminal device and the computing power of edge nodes and other related data. In other words, the distributed computing network architecture of the present invention is dynamically constructed based on the real-time status of each terminal device and each node, and the basis of dynamic construction is based on the multi-objective optimization model constructed in step S2.

[0020] S2: Set the optimization objectives and constraints of the multi-objective optimization model, construct a mathematical model framework for the multi-objective optimization model, and use a specified optimization algorithm to solve the multi-objective optimization model to obtain the optimal solution that meets the optimization objectives and constraints. The multi-objective optimization model has the optimization objectives of minimizing task processing latency, maximizing resource utilization, and minimizing energy consumption. The constraints are the upper limit of computing resources, network bandwidth limitations, and the requirements for secure transmission of task data.

[0021] S3: Based on the optimal solution, a distributed computing network architecture is dynamically constructed in real time. The roles and task allocation relationships of each edge node in the network are determined, and a distributed edge computing network consisting of multiple edge nodes and a central node is constructed. This distributed computing network architecture, constructed based on the solution of the multi-objective optimization model, can achieve low task processing latency, high resource utilization, and low energy consumption for tasks within the network, subject to the constraints of computing resource limits, network bandwidth limitations, and secure task data transmission requirements.

[0022] S4: Based on the computing power status of the terminal device and network latency, the computing task is decomposed into N heterogeneous subtasks and the subtask granularity is optimized. Prioritize the optimized subtasks and pre-assign initial edge nodes. Decomposing the computing task into N heterogeneous subtasks and optimizing the subtask granularity provides a foundation for subsequent priority setting and task allocation. Pre-assigning adaptive edge nodes facilitates the collaborative processing of large-scale tasks.

[0023] S5: Based on the node credit evaluation mechanism of blockchain, the task allocation weight is dynamically adjusted, and the dynamic migration of subtasks between edge nodes is achieved through local edge node decision-making and central node arbitration.

[0024] S6: When the edge node is offline, a preset diffusion scheme is used to perform computational relay to preprocess all subtasks. Each edge node sends the preprocessed data that needs to be deeply processed to the central node for deep processing before returning it to the edge node. S7: The edge node directly returns the pre-processed data that does not require deep processing to the terminal device, and returns the deeply processed data to the terminal device.

[0025] In this embodiment, terminal device task information is collected via embedded sensors and lightweight monitoring agents. Task types, including compute-intensive and I / O-intensive, as well as multi-dimensional characteristics such as data volume, real-time requirements, and security levels, are collected in real time. A time window sliding sampling mechanism, combined with a Kalman filter algorithm, is used to predict task growth trends and generate task feature vectors. Edge node computing power data is collected via a distributed resource monitoring system. Dynamic indicators such as CPU / GPU utilization, memory usage, network bandwidth usage, and remaining storage capacity are periodically collected. The DBSCAN density clustering algorithm is used to identify abnormal points in computing power fluctuations and construct a time series model of node resource status.

[0026] A dynamic credit scoring model is constructed by recording the node's historical task completion rate, response delay, computing power stability and other data through blockchain. A fuzzy logic algorithm is used to map the credit score to the task allocation weight, so that high-credit nodes are given priority to obtain key subtasks. Reasonable allocation is made based on the actual performance of the nodes, ensuring that resources are tilted towards more reliable and efficient nodes, improving the overall efficiency of task processing, and at the same time ensuring the fairness of the task allocation process, and incentivizing each node to actively improve its own performance.

[0027] Leveraging the blockchain's immutable and traceable nature, node credit data and task migration arbitration results are recorded and stored on-chain, preventing malicious nodes from tampering with data or manipulating the task allocation process. During the subtask migration process, smart contracts verify the legitimacy of the migration. Only migration requests that comply with the rules are executed, further ensuring system security and reducing the risk of system failures or data leaks caused by malicious attacks.

[0028] Local edge nodes trigger subtask migration requests based on real-time load and credit thresholds, with central nodes arbitrating. This combination of local decision-making and centralized arbitration enables rapid response based on real-time node status. When a node experiences excessive load or performance degradation, subtasks are promptly migrated to more suitable nodes, avoiding task backlogs and ensuring continuous and efficient task execution. Furthermore, migrating tasks is matched to the target node's computing power and network status using the Hungarian algorithm. During the migration process, task context is synchronized via a lightweight blockchain to ensure consistent and continuous task execution, enhancing the system's ability to cope with complex tasks and dynamic environments. This mechanism enables the system to maintain overall operation by dynamically migrating subtasks even when some nodes experience failures or unstable performance. Tasks from low-credit or offline nodes can be reassigned to other reliable nodes, ensuring that computing tasks are not interrupted by individual node issues. This enhances the system's fault tolerance and reliability, ensuring the stable operation of the distributed edge computing network.

[0029] Example 2 Based on Example 1, see Figure 2 The specific process of setting the optimization objectives and constraints of the multi-objective optimization model and constructing the mathematical model framework of the multi-objective optimization model in step S2 is as follows: S21: Setting the optimization objectives of the multi-objective optimization model includes minimizing task processing delay, maximizing resource utilization, and minimizing energy consumption; S22: Setting constraints for the multi-objective optimization model includes computing resource upper limit constraints, network bandwidth limit constraints, and task data security transmission requirement constraints; S23: Constructing a mathematical model framework of a multi-objective optimization model based on the optimization objectives and constraints, defining decision variables of the mathematical model framework, and constructing an objective function and its constraints.

[0030] The above-mentioned process of constructing the mathematical model framework of the multi-objective optimization model serves to build an optimization decision-making framework that can balance multi-dimensional goals and cope with complex constraints. Its core technical purpose is to achieve efficient resource allocation and intelligent task scheduling in a distributed edge computing environment.

[0031] In edge computing environments, the three objectives of task processing latency, resource utilization, and energy consumption are interrelated and conflicting. For example, reducing latency may require increasing resource allocation, leading to increased energy consumption, while improving resource utilization may increase latency on some nodes due to task concentration. Traditional single-objective optimization methods are unable to effectively address this complex trade-off.

[0032] Constraints in edge computing networks, such as computing resource limits, network bandwidth limitations, and data security requirements, are dynamic and constantly changing. For example, network bandwidth fluctuates with user traffic, and security requirements vary depending on the task type. Making optimal decisions within these dynamic constraints is a key challenge. Edge computing networks typically consist of a large number of heterogeneous nodes, including devices with varying computing power, storage capacity, and network bandwidth. Achieving global optimization and avoiding local optimal solutions in this heterogeneous environment is crucial to improving overall system performance.

[0033] The technical solution implemented in this invention quantitatively models the three objectives of minimizing task processing latency, maximizing resource utilization, and minimizing energy consumption, establishing a mathematical model that comprehensively considers multiple objectives. This multi-objective optimization method can find a set of Pareto optimal solutions, providing decision makers with multiple options. Constraints such as computing resource limits, network bandwidth limitations, and secure task data transmission requirements are converted into mathematical expressions, ensuring that the optimization process is carried out within the feasible solution space.

[0034] Decision variables and objective function design: Define the decision variables x ij and y ij To represent the task allocation relationship and resource occupancy, the corresponding objective function and constraint conditions are constructed, so that the multi-objective optimization model can accurately reflect the resource allocation and task scheduling problems in the edge computing environment.

[0035] By simultaneously considering multiple optimization objectives and constraints, efficient configuration of computing resources, storage resources, and network resources is achieved. While satisfying various constraints, resource utilization is maximized, energy consumption is reduced, and task processing latency is minimized. The optimized task allocation and resource scheduling strategies can significantly improve the performance of the entire edge computing system. For example, by minimizing task processing latency, the response speed of real-time applications can be improved; by maximizing resource utilization, system construction costs can be reduced; and by minimizing energy consumption, the service life of equipment can be extended and energy consumption reduced. The multi-objective optimization model can adapt to dynamic changes in the edge computing environment, including node joining or exiting, load fluctuations, and changes in network status. By adjusting task allocation and resource scheduling strategies in real time, the system can maintain good performance under various dynamic conditions.

[0036] The detailed execution process of step S23 is as follows: S231: The decision variables of the mathematical model framework of the multi-objective optimization model are defined as x ij , when the task i ( i =1,2,⋯,n ) assigned to edge nodes j ( j =1,2,⋯, m )hour, x ij =1; otherwise x ij =0, let y ij is a continuous variable, indicating the task i Assign to edge nodes j The amount of computing resources used when S232: Objective function of mathematical model framework for constructing multi-objective optimization model: ; ; ; Among them, Z1 is the objective function of minimizing task processing delay, Z2 is the objective function of maximizing resource utilization, and Z3 is the objective function of minimizing energy consumption. For the task i At the edge node j The waiting time in queues, For the task i Transmitted from terminal devices to edge nodes j time, For the task i At the edge node j The actual computation processing time on α j 、 β j 、 γ j These are the weight coefficients of CPU, storage, and network resource utilization respectively; R j c 、 R j s 、 R j b Edge nodes j The total amount of CPU, storage, and network resources; s ij 、 b ij Respectively for tasks i The amount of storage resources and network bandwidth occupied on edge node j, e j ( y ij ) is an edge node j Processing tasksi Based on the amount of computing resources occupied y ij Energy consumption function; S233: Constraints for establishing the mathematical model framework of the target optimization model: Computing resource upper limit constraints: ; Network bandwidth limitations and constraints: ; Task data security transmission requirements and constraints: ; Among them, Security i , j ) indicates a task i At the edge node j The safety standard function that is satisfied during processing returns 1 if satisfied, otherwise returns 0; Task assignment uniqueness constraint: .

[0037] In step S2, the specified optimization algorithm is used to solve the multi-objective optimization model to obtain the optimal solution that meets the optimization objectives and constraints. The specific process is as follows: S24: Use matrix coding to represent each task as [ x 1, x 2,..., x n ] T ,in x i Corresponding edge node i The task allocation ratio is improved by introducing a dynamic gene length mechanism to adapt to topological changes with variable node numbers; S25: Generate an initial solution set based on the node capability graph to ensure that: , and 0≤ x j ≤ C i max ; C i max For nodes i Maximum load factor; S26: Adopt the ε-dominance screening method to retain high-quality solutions with a spacing greater than the threshold ε, establish a solution set archive, record the evolution trajectory of the historical optimal solution, and calculate the 95% confidence interval of the target value through Bootstrap sampling. Set the key perturbation parameters to verify the robustness of the optimal solution.

[0038] Example 3 Based on Example 1 or Example 2, in step S3, a distributed computing network architecture is dynamically constructed in real time based on the optimal solution, the role and task allocation relationship of each edge node in the network is determined, and the specific process of constructing a distributed edge computing network consisting of multiple edge nodes and a central node is as follows: S31: Deploy a central node with global scheduling capabilities based on node performance, load the dynamic game algorithm framework, and initialize the resource database and topology map.

[0039] By obtaining the computing power of each node, including CPU / GPU frequency, number of cores, as well as memory capacity, network bandwidth, and stability, we establish a candidate set of central nodes and select the node with the highest overall score from this set as the central node. We define the policy space: S = {s1 (data preprocessing), s2 (model inference), s3 (relay transmission)}, set the reward function, and use a graph data structure to represent the network topology: G = (V, E) for edge weight calculation. We use the Dijkstra algorithm to precompute the shortest path matrix and construct a topology map.

[0040] S32: The edge node reports the metadata of computing power, storage, and location to the central node through a lightweight protocol to form an initial resource pool.

[0041] Based on the CoAP protocol extension, it supports UDP multicast communication. The message format is: { "node_id": "0xABC123", "timestamp": 1693542180, "cpu_available": 75%, "memory_available": 60%, "storage_available": 85GB, "location": {"lat": 30.1234, "lng": 120.5678}, "status": "online"} The MsgPack binary serialization format is used for data compression, a sliding time window is used to filter out outdated data, a Kalman filter is applied to smooth resource fluctuation data, a 2D spatial index is built based on the GeoHash algorithm, a multidimensional B+ tree index is built, and range queries are supported.

[0042] S33: Based on real-time load and task requirements, the central node calculates the optimal role of each node through the potential game algorithm, including data preprocessing nodes, model inference nodes, and relay nodes, and periodically evaluates the node status and sets the node role reallocation trigger conditions. When the reallocation trigger conditions are met, role reallocation is triggered.

[0043] Construct a system state vector, which includes each node's load vector and resource vector. Initialize all node roles, periodically evaluate node status, and set trigger conditions for node role reallocation. When these conditions are met, role reallocation is triggered. The reallocation process is as follows: mark nodes that require adjustment, perform local reallocation, and prioritize finding replacements among the faulty node's neighbors. Finally, perform global rebalancing, which triggers a network-wide role recalculation if local adjustments fail.

[0044] See the diagram of the distributed computing network architecture created. Figure 3 As shown, the computing power of each node is obtained in real time to determine the central node. The central node may change according to the real-time status of each node. Therefore, the central node is dynamic and the edge node is also dynamic. The tasks generated by the terminal device are transmitted to the edge node. The edge node performs preliminary processing and compresses the data before transmitting it to the central node. The central node processes it through the multi-task scheduling module to generate a task queue. The central node processes the tasks according to the task queue.

[0045] In step S4, the computing task is decomposed into N heterogeneous subtasks according to the computing power status of the terminal device and the network delay, and the subtask granularity is optimized. The specific process of setting the priority of the optimized subtasks and pre-allocating the initial edge nodes is as follows: S41: Use performance probes to collect node CPU / GPU computing power, memory, and network latency data to build a resource feature matrix. S42: Optimizing the subtask granularity using a genetic algorithm based on the resource feature matrix and task type to ensure that the computing task granularity matches the node computing power; S43: Identify critical subtasks based on the task dependency graph and assign them the highest priority to reduce overall latency. Dynamically adjust priority weights based on business SLA requirements. Use the Hungarian algorithm to match the remaining computing power of edge nodes with the network topology based on subtask resource requirements, prioritize low-latency nodes, pre-allocate backup nodes for high-priority subtasks, and implement fault switching within seconds through heartbeat detection.

[0046] The specific process of optimizing the subtask granularity using a genetic algorithm based on the resource feature matrix and task type in step S42 is as follows: S421: Define a subtask granularity encoding range based on computation intensiveness or IO intensiveness.

[0047] S422: Encode the subtask granularity into chromosomes, use real number encoding to adapt to continuous parameter optimization, take task processing delay, resource utilization, and energy consumption as optimization targets, dynamically adjust the weight coefficient, and iteratively optimize and converge to the optimal solution through arithmetic crossover and elite retention strategies.

[0048] The iterative optimization process is: Initialize the population, randomly generate N chromosomes, and calculate the initial population fitness; apply elite retention, save the best K chromosomes, generate a mating pool through tournament selection, perform arithmetic crossover on the chromosomes in the mating pool, perform Gaussian mutation on the crossover results, merge the elite chromosomes with the newly generated chromosomes to form a new chromosome, calculate the fitness, and exit the loop if the convergence condition is met, and finally return to the optimal chromosome.

[0049] S423: Match the node with the most suitable computing power in the resource matrix according to the optimized subtask requirements.

[0050] Example 4 On the basis of Example 1, Example 2, or Example 3, in step S5, the node credit evaluation mechanism based on the blockchain dynamically adjusts the task allocation weight, and the specific process of dynamically migrating subtasks between edge nodes through local edge node decision-making and central node arbitration is as follows: S51: Build a dynamic credit scoring model by recording the node's historical task completion rate, response delay, and computing power stability data through the blockchain; S52: A fuzzy logic algorithm is used to map credit scores to task allocation weights, with high-credit nodes receiving key subtasks first. S53: The local node triggers a subtask migration request based on real-time load and credit thresholds. The rationality of the migration is verified through smart contracts to prevent malicious node manipulation. The arbitration results are stored on the chain. S54: Based on the Hungarian algorithm, the migration task is matched with the computing power and network status of the target node. During the migration process, the task context is synchronized through a lightweight blockchain to ensure consistency.

[0051] A data collection module is deployed on each edge node to monitor task completion, response latency, and computing power stability in real time. Task completion rate is calculated by measuring the ratio of the number of tasks successfully processed by a node to the total number of tasks received. Response latency measures the time interval between task issuance and the return of a result by the node. Computing power stability is determined by fluctuations in CPU and GPU usage during task processing. The collected data is hashed and broadcast to other nodes via the blockchain's P2P network. Each node verifies the data's validity and packages it into a new block, ensuring an unalterable record of the data.

[0052] The weighted average method is used to construct a dynamic credit scoring model, assuming that the historical task completion rate is C rate , the response delay is D delay , computing power stability is S stable , and the corresponding weight coefficients are α 、 β 、 γ ( α + β + γ =1), credit score S core .

[0053] The calculation formula is as follows: .

[0054] in, C rate ∈[0, 1], D delay Take the inverse of the average response delay of the node over a period of time, S stable ∈[0,1]. The weight coefficient is dynamically adjusted according to different application scenarios through the hierarchical analysis method. At the same time, in order to reflect the importance of the node's recent performance, the time decay factor is introduced δ ,(0< δ <1), weight the historical data, and the data weight gradually decreases over time.

[0055] Credit scores are divided into multiple fuzzy sets, such as "low credit," "medium credit," and "high credit." Corresponding membership functions are defined. For example, a Z-type membership function is used for "low credit," a trapezoidal membership function is used for "medium credit," and an S-type membership function is used for "high credit." Based on the node's credit score, its membership in each fuzzy set is calculated.

[0056] Establish a fuzzy rule base: If the node credit is "high credit", the task allocation weight is "high"; If the node credit is "medium credit", the task allocation weight is "medium"; If the node credit is "low credit", the task allocation weight is "low".

[0057] The center of gravity method is used to convert fuzzy output into specific task allocation weight values. By calculating the center of gravity coordinates of the fuzzy set, the final task allocation weight is obtained, so that high-credit nodes receive higher weights and thus receive priority for key subtasks.

[0058] Local edge nodes monitor their load in real time. When the load exceeds a set threshold and the node's credit score falls below the threshold, a subtask migration request is triggered. This migration request contains information about the subtask to be migrated, such as task type, data volume, and computational requirements. The subtask migration request is sent to the blockchain network, where a smart contract verifies it based on pre-set rules. These rules include whether the target node's load falls below a certain threshold, whether the target node's credit score meets requirements, and whether the migration will disrupt task processing on the source node. Only verified migration requests are executed, preventing malicious nodes from disrupting system operations through false migration requests. In the event of a dispute over a migration request, such as when multiple nodes compete for the same subtask, arbitration is handled by the central node. The central node makes arbitration decisions based on factors such as each node's credit score, load, and task priority. The arbitration results are recorded on the blockchain via a smart contract, ensuring transparency and traceability throughout the migration process.

[0059] A matrix of the target node's computing power and network status is constructed. The matrix elements include the node's remaining CPU computing power, remaining memory capacity, remaining network bandwidth, and other factors. The computational requirements and network transmission requirements of the subtasks to be migrated are used as cost functions. The Hungarian algorithm is used to solve the minimum cost allocation solution and determine the optimal matching relationship between the subtasks and the target node. During the task migration process, lightweight blockchain technology is used to synchronize task context information, including subtask execution progress, intermediate calculation results, and data dependencies. Task context data is linked to the blockchain via hash pointers. The target node can obtain the complete and accurate task context by verifying the hash value, ensuring that the task can continue to execute seamlessly after migration and maintaining consistency in task processing.

[0060] The specific process of step S6 is as follows: S61: Detect node status at specified intervals through the 5G MEC network. If a node exceeds a specified number of times, it is considered offline. Then, based on the preset topology, the subtasks of the offline node are spread to adjacent designated edge nodes according to priority to ensure preprocessing continuity. S62: Online nodes perform data preprocessing, compressing the data to a specified ratio of the original data, and annotating complex tasks that require central processing through metadata, along with a description of the node's computing power requirements. S63: Low-latency fiber channels are used to transmit labeled data, and the central GPU cluster completes AI reasoning / large-scale computing. The processing results are verified by the edge gateway and then distributed to the original edge node.

[0061] In 5G MEC (Mobile Edge Computing) networks, a dedicated heartbeat detection module is deployed. This module sends status detection requests to each edge node every T time interval. Upon receiving the request, the node immediately returns a response packet containing information such as its CPU usage, memory usage, and network connection status. If the central node does not receive a response from a node within the specified time interval T, it is considered a timeout. If the same node times out N times consecutively, it is considered offline.

[0062] Establish a subtask priority evaluation system, assigning different priorities based on factors such as real-time requirements, business importance, and data processing stage. For example, real-time data processing tasks for emergency obstacle avoidance in autonomous driving scenarios are assigned the highest priority, while log analysis tasks are assigned a lower priority. Priorities are denoted by numbers, with higher numbers indicating higher priority. Based on the pre-set network topology, the central node constructs a node adjacency graph. If a node goes offline, the central node traverses its subtask list from highest to lowest, prioritizing the diffusion of subtasks to adjacent edge nodes with loads below a threshold. During this diffusion process, subtask descriptions are rapidly transmitted via 5G low-latency communication channels to ensure the continuity of preprocessing. After receiving a data processing task, the online node first determines the data type. For multimedia data such as images and videos, an efficient compression algorithm is used to compress the data volume to the R ratio of the original data; for structured data, dictionary compression, differential encoding, and other methods are used for compression. Metadata annotation specifications are established, and online nodes analyze the task processing logic to identify complex subtasks that require central nodes to perform AI reasoning or large-scale computing. For these tasks, special identifiers are added to the metadata, and the computing power resources required for the task are detailed. For example, for an image recognition task, it is marked that it requires the use of the ResNet-50 model and occupies at least 2 GPU cores and 8GB of video memory. A dedicated low-latency fiber optic network is built to connect edge nodes with the central node. After receiving the labeled, pre-processed data, the central node distributes the data to the corresponding GPU cluster computing node based on the task requirements in the metadata. During transmission, a high-speed data transmission protocol is used to reduce data transmission latency and network congestion. The GPU cluster dynamically allocates computing resources based on the task type and computing power requirements. For AI inference tasks, the corresponding deep learning model is loaded to process the data. For large-scale computing tasks, a distributed computing framework is used for parallel computing. After processing, the results are packaged, including the processing result data, task execution status, and other information. After receiving the processing results from the central node, the edge gateway first performs a completeness and accuracy check. By calculating the hash value of the result data and comparing it with the hash value before transmission, it verifies that the data has not been tampered with during transmission. Furthermore, the validity of the result is verified based on the task type. Once the verification passes, the edge gateway distributes the result to the original edge node, which then proceeds with subsequent data processing or returns it to the end device based on the result.

[0063] In summary, the distributed edge computing method for data communication provided by the present invention creates a multi-objective optimization model by collecting terminal device task information and edge node computing power data in real time, and sets optimization goals such as minimizing task processing delay, maximizing resource utilization, minimizing energy consumption, and multiple constraints. It is combined with a specified optimization algorithm to solve the optimal solution, and can accurately and reasonably allocate and schedule tasks. It reduces task processing delay, improves task execution efficiency, reduces unnecessary energy consumption, and improves overall resource utilization. Based on the optimal solution, a distributed computing network architecture is dynamically constructed in real time to determine the relationship between the role of each edge node and the task allocation. The central node uses a dynamic game algorithm framework, combined with the metadata reported by the edge node to form a resource pool, and calculates the optimal role of the node through a potential game algorithm, so that the network architecture can be flexibly adjusted according to real-time load and task requirements, significantly enhancing the adaptability and flexibility of the network. Computing tasks are decomposed and subtask granularity optimized based on the computing power status of terminal devices and network latency. Genetic algorithms are used to optimize subtask granularity to match node computing power. Priorities and pre-assigned nodes are set based on the task dependency graph and business SLA requirements, ensuring that computing tasks can be efficiently executed on the most appropriate nodes and reducing mutual interference between tasks. A blockchain-based node credit assessment mechanism dynamically adjusts task allocation weights, and dynamic subtask migration is achieved through local edge node decision-making and central node arbitration. This ensures the fairness and rationality of task allocation while improving the security and stability of the system. When edge nodes go offline, a pre-set diffusion scheme implements computational relay and data preprocessing. The central node performs in-depth processing of specific data, ensuring the smooth completion of all subtasks and maintaining data processing continuity.

Claims

1. A distributed edge computing method for data communication, characterized in that: The following steps are involved: S1: Collect task information of each terminal device and computing power data of edge nodes in real time, and create a multi-objective optimization model based on the task information of each terminal device and computing power data of edge nodes; S2: Setting the optimization objectives and constraints of the multi-objective optimization model, building a mathematical model framework for the multi-objective optimization model, and solving the multi-objective optimization model using a specified optimization algorithm to obtain an optimal solution that meets the optimization objectives and constraints; S3: Dynamically builds a distributed computing network architecture in real time based on the optimal solution, determines the role and task allocation relationship of each edge node in the network, and builds a distributed edge computing network consisting of multiple edge nodes and a central node; S4: Based on the computing power status of the terminal device and network latency, the computing task is decomposed into N heterogeneous subtasks and the subtask granularity is optimized. Priorities are set for the optimized subtasks and initial edge nodes are pre-assigned. S5: Based on the blockchain node credit evaluation mechanism, task allocation weights are dynamically adjusted. At the same time, subtasks are dynamically migrated between edge nodes through local edge node decision-making and central node arbitration. S6: When the edge node is offline, a preset diffusion scheme is used to perform computational relay to preprocess all subtasks. Each edge node sends the preprocessed data that needs to be deeply processed to the central node for deep processing before returning it to the edge node. S7: The edge node directly returns the pre-processed data that does not require deep processing to the terminal device, and returns the deeply processed data to the terminal device.

2. A distributed edge computing method for data communication according to claim 1, characterized in that: The specific process of setting the optimization objectives and constraints of the multi-objective optimization model and constructing the mathematical model framework of the multi-objective optimization model in step S2 is as follows: S21: Setting the optimization objectives of the multi-objective optimization model includes minimizing task processing delay, maximizing resource utilization, and minimizing energy consumption; S22: Setting constraints for the multi-objective optimization model includes computing resource upper limit constraints, network bandwidth limit constraints, and task data security transmission requirement constraints; S23: Constructing a mathematical model framework of a multi-objective optimization model based on the optimization objectives and constraints, defining decision variables of the mathematical model framework, and constructing an objective function and its constraints.

3. A distributed edge computing method for data communication according to claim 2, characterized in that: The detailed execution process of step S23 is as follows: S231: The decision variables of the mathematical model framework of the multi-objective optimization model are defined as x ij , when the task i ( i =1,2,⋯, n ) assigned to edge nodes j ( j =1,2,⋯, m )hour, x ij =1; otherwise x ij =0, let y ij is a continuous variable, indicating the task i Assign to edge nodes j The amount of computing resources used when S232: Objective function of mathematical model framework for constructing multi-objective optimization model: ； ； ； Among them, Z1 is the objective function of minimizing task processing delay, Z2 is the objective function of maximizing resource utilization, and Z3 is the objective function of minimizing energy consumption. For the task i At the edge node j The waiting time in queues, For the task i Transmitted from terminal devices to edge nodes j time, For the task i At the edge node j The actual computation processing time on α j 、 β j 、 γ j These are the weight coefficients of CPU, storage, and network resource utilization respectively; R j c 、 R j s 、 R j b Edge nodes j The total amount of CPU, storage, and network resources; s ij 、 b ij Respectively for tasks i The amount of storage resources and network bandwidth occupied on edge node j, e j ( y ij ) is an edge node j Processing tasks i Based on the amount of computing resources occupied y ij Energy consumption function; S233: Constraints for establishing the mathematical model framework of the target optimization model: Computing resource upper limit constraints: ； Network bandwidth limitations and constraints: ； Task data security transmission requirements and constraints: ； Among them, Security i , j ) indicates a task i At the edge node j The safety standard function that is satisfied during processing returns 1 if satisfied, otherwise returns 0; Task assignment uniqueness constraint: 。 4. A distributed edge computing method for data communication according to claim 3, characterized in that: In step S2, the specified optimization algorithm is used to solve the multi-objective optimization model to obtain the optimal solution that meets the optimization objectives and constraints. The specific process is as follows: S24: Use matrix coding to represent each task as [ x 1, x 2,..., x n ] T ,in x i Corresponding edge node i The task allocation ratio is improved by introducing a dynamic gene length mechanism to adapt to topological changes with variable node numbers; S25: Generate an initial solution set based on the node capability graph to ensure that: j =1, and 0≤ x j ≤ C i max ; C i max For nodes j Maximum load factor; S26: Adopt the ε-dominance screening method to retain high-quality solutions with a spacing greater than the threshold ε, establish a solution set archive, record the evolution trajectory of the historical optimal solution, and calculate the 95% confidence interval of the target value through Bootstrap sampling. Set the key perturbation parameters to verify the robustness of the optimal solution.

5. A distributed edge computing method for data communication according to claim 1, characterized in that: In step S3, a distributed computing network architecture is dynamically constructed in real time based on the optimal solution, and the role and task allocation relationship of each edge node in the network are determined. The specific process of constructing a distributed edge computing network consisting of multiple edge nodes and a central node is as follows: S31: Deploy a central node with global scheduling capabilities based on node performance, load the dynamic game algorithm framework, and initialize the resource database and topology map; S32: The edge node reports the metadata of computing power, storage, and location to the central node through a lightweight protocol to form an initial resource pool; S33: Based on real-time load and task requirements, the central node calculates the optimal role of each node through the potential game algorithm, including data preprocessing nodes, model inference nodes, and relay nodes, and periodically evaluates the node status and sets the node role reallocation trigger conditions. When the reallocation trigger conditions are met, role reallocation is triggered.

6. A distributed edge computing method for data communication according to claim 1, characterized in that: In step S4, the computing task is decomposed into N heterogeneous subtasks according to the computing power status of the terminal device and the network delay, and the subtask granularity is optimized. The specific process of setting the priority of the optimized subtasks and pre-allocating the initial edge nodes is as follows: S41: Use performance probes to collect node CPU / GPU computing power, memory, and network latency data to build a resource feature matrix. S42: Optimizing the subtask granularity using a genetic algorithm based on the resource feature matrix and task type to ensure that the computing task granularity matches the node computing power; S43: Identify critical subtasks based on the task dependency graph and assign them the highest priority to reduce overall latency. Dynamically adjust priority weights based on business SLA requirements. Use the Hungarian algorithm to match the remaining computing power of edge nodes with the network topology based on subtask resource requirements, prioritize low-latency nodes, pre-allocate backup nodes for high-priority subtasks, and implement fault switching within seconds through heartbeat detection.

7. A distributed edge computing method for data communication according to claim 1, characterized in that: The specific process of optimizing the subtask granularity using a genetic algorithm based on the resource feature matrix and task type in step S42 is as follows: S421: defining a subtask granularity coding range based on computation intensiveness or IO intensiveness; S422: Encode the subtask granularity into chromosomes and use real number encoding to adapt to continuous parameter optimization. Take task processing latency, resource utilization, and energy consumption as optimization targets, dynamically adjust weight coefficients, and iterate and optimize to converge to the optimal solution through arithmetic crossover and elite retention strategies. S423: Match the node with the most suitable computing power in the resource matrix according to the optimized subtask requirements.

8. A distributed edge computing method for data communication according to claim 1, characterized in that: In step S5, the node credit evaluation mechanism based on the blockchain dynamically adjusts the task allocation weights. At the same time, the dynamic migration of subtasks between edge nodes is achieved through local edge node decision-making and central node arbitration. The specific process is as follows: S51: Build a dynamic credit scoring model by recording the node's historical task completion rate, response delay, and computing power stability data through the blockchain; S52: A fuzzy logic algorithm is used to map credit scores to task allocation weights, with high-credit nodes receiving key subtasks first. S53: The local node triggers a subtask migration request based on real-time load and credit thresholds. The rationality of the migration is verified through smart contracts to prevent malicious node manipulation. The arbitration results are stored on the chain. S54: Based on the Hungarian algorithm, the migration task is matched with the computing power and network status of the target node. During the migration process, the task context is synchronized through a lightweight blockchain to ensure consistency.

9. A distributed edge computing method for data communication according to claim 1, characterized in that: The specific process of step S6 is as follows: S61: Detect node status at specified intervals through the 5G MEC network. If a node exceeds a specified number of times, it is considered offline. Then, based on the preset topology, the subtasks of the offline node are spread to adjacent designated edge nodes according to priority to ensure preprocessing continuity. S62: Online nodes perform data preprocessing, compressing the data to a specified ratio of the original data, and annotating complex tasks that require central processing through metadata, along with a description of the node's computing power requirements. S63: Low-latency fiber channels are used to transmit labeled data, and the central GPU cluster completes AI reasoning / large-scale computing. The processing results are verified by the edge gateway and then distributed to the original edge node.

Images