Low-delay and high-reliability distributed integrated optimization method for cloud collaborative computer system

Abstract

The invention relates to the technical field of cloud computing and edge computing, and discloses a low-delay and high-reliability distributed integrated optimization method for a cloud collaborative computer system, which comprises the following steps of: S1, acquiring node state data of a plurality of collaborative nodes, processing the node state data based on a reinforcement learning model, and generating a task allocation strategy and a data routing strategy; s2, receiving local resource optimization parameters generated by each cooperative node based on federated learning, and aggregating the local resource optimization parameters to generate a global resource allocation strategy; and S3, obtaining a task allocation log and a resource scheduling log recorded by the block chain network, and verifying execution states of task allocation and resource scheduling based on the smart contract. According to the invention, the DQN, FedProx and block chain technologies are integrated, the cooperation of task allocation, resource optimization and fault self-healing is realized, the performance of the cloud system is optimized, and the problems of task allocation and resource scheduling separation and low fault recovery efficiency of a traditional cloud system are solved.

Description

Technical Field

[0001] The present invention relates to the technical fields of cloud computing and edge computing, and particularly to a distributed integrated optimization method for a low-latency and high-reliability cloud-edge collaborative computer system. Background Art

[0002] With the wide application of cloud computing and edge computing, cloud-edge collaborative computer systems have played an important role in fields such as autonomous driving, smart cities, and industrial Internet of Things. In the prior art, task allocation usually adopts algorithms based on load balancing, such as round-robin or heuristic scheduling, to dispatch computing tasks to cloud servers or edge nodes. In terms of resource optimization, some systems use centralized management or simple distributed algorithms to allocate resources according to node computing capabilities and network status. Fault recovery relies on redundant backups or manual intervention, and maintains system stability through logging and retry mechanisms. These technologies have initially realized the basic functions of cloud-edge collaborative computing through task scheduling, resource management, and fault handling.

[0003] However, the prior art has significant deficiencies in the coordination of task allocation, resource optimization, and fault self-healing. Task allocation algorithms are usually independent of resource management, lacking comprehensive consideration of dynamic network status and resource allocation results, resulting in low allocation efficiency. Resource optimization mostly adopts centralized solutions, ignoring the local load characteristics of distributed nodes and being difficult to adapt to large-scale collaboration scenarios. The fault self-healing process is separated from task allocation and resource management, and the recovery mechanism responds slowly, affecting the overall performance of the system. Summary of the Invention

[0004] To make up for the above deficiencies, the present invention provides a distributed integrated optimization method for a low-latency and high-reliability cloud-edge collaborative computer system, aiming to improve the problem that the fault self-healing process is separated from task allocation and resource management in the coordination of task allocation, resource optimization, and fault self-healing in the prior art.

[0005] In a first aspect, the present invention provides the following technical solution. A distributed integrated optimization method for a low-latency and high-reliability cloud-edge collaborative computer system, applied to a server, includes the following steps: S1, obtaining node status data of multiple collaborative nodes, processing the node status data based on a reinforcement learning model, and generating a task allocation strategy and a data routing strategy; S2, receiving local resource optimization parameters generated by each collaborative node based on federated learning, aggregating the local resource optimization parameters to generate a global resource allocation strategy, and sending the global resource allocation strategy to each collaborative node to coordinate resource allocation; S3. Obtain the task allocation log and resource scheduling log recorded by the blockchain network, verify the execution status of the task allocation and resource scheduling based on the smart contract, and trigger the fault self-healing process when a node failure is detected to reallocate tasks.

[0006] Through the above technical solution, in step S1, the monitoring agent collects node status data (such as latency, load), and uses the Dueling DQN algorithm to generate task allocation and data routing strategies to optimize latency and reliability; in step S2, the FedProx algorithm is used to receive the local resource optimization parameters of the nodes, securely aggregate them to generate the global resource allocation strategy, and send it to the nodes to adjust resources; in step S3, based on the blockchain network to record task and resource logs, verify the execution status through the smart contract, and call DQN to reallocate tasks when a failure occurs; the three are linked by sharing node status data. The DQN task allocation depends on the FedProx resource strategy, and the blockchain log feeds back to adjust DQN, jointly optimizing task allocation, resource management, and fault self-healing.

[0007] Preferably, the step S1 includes: S101. Obtain the network latency, computing load, node reliability, and data transmission bandwidth of the collaborative nodes through the monitoring agent to generate the node status data; S102. Based on the node status data, construct a reinforcement learning model. The state space of the reinforcement learning model includes node status, task requirements, and network topology, and the action space includes task allocation and data routing. The reward function is defined as:

[0008] where R is the reward value, used to evaluate the pros and cons of the task allocation strategy and data routing strategy; α is the weight coefficient of latency, adjusting the impact of latency on the reward value; Latency is the latency of task execution, in milliseconds; β is the weight coefficient of reliability, adjusting the impact of reliability on the reward value; Reliability is the reliability of the node, ranging from 0 to 1; S103. Use the deep Q network to train the reinforcement learning model to generate the task allocation strategy and data routing strategy.

[0009] Preferably, the monitoring agent in step S101 collects the node status data at a frequency of once per second to adapt to dynamic load changes.

[0010] Preferably, the step S2 includes: S201. Receive the local resource optimization parameters trained by each collaborative node based on local load and task requirements. The local resource optimization parameters are added with noise through differential privacy technology to protect data privacy; S202, Aggregate the local resource optimization parameters through a secure aggregation protocol to generate the global resource allocation policy; S203, Send the global resource allocation policy to each collaborative node to trigger the collaborative node to adjust the allocation of computing resources, storage, and bandwidth.

[0011] Preferably, the training of the local resource optimization parameters is based on the node status data, and the output of the global resource allocation policy includes the resource allocation schemes of each collaborative node.

[0012] Preferably, the step S3 includes: S301, Obtain the task allocation log and resource scheduling log recorded in the distributed ledger of the blockchain network; S302, Verify whether the execution of the task allocation and resource scheduling meets the latency and reliability requirements through a service level agreement verification contract; S303, When a node failure is detected, trigger the self-healing contract to call the reinforcement learning model to generate a new task allocation policy, and re-allocate tasks to highly reliable nodes. The execution time of the fault self-healing process is controlled within 100 milliseconds.

[0013] Preferably, the task allocation policy, the global resource allocation policy, and the fault self-healing process are linked by sharing the node status data, where: S4, The global resource allocation policy optimizes resource allocation based on the node status data; S5, The task allocation policy selects an execution node according to the global resource allocation policy; S6, The blockchain network uses a practical Byzantine fault tolerance consensus mechanism to record the execution logs of the task allocation policy and the global resource allocation policy.

[0014] In a second aspect, the present invention provides the following technical solution, a low-latency and high-reliability cloud collaborative computer system distributed integration optimization system, the system includes: A data processing module configured to obtain the node status data of multiple collaborative nodes, process the node status data based on a reinforcement learning model, and generate a task allocation policy and a data routing policy; A resource optimization module configured to receive the local resource optimization parameters generated by each collaborative node based on federated learning, aggregate the local resource optimization parameters to generate a global resource allocation policy, and send the global resource allocation policy to each collaborative node; A verification and self-healing module configured to obtain the task allocation log and resource scheduling log recorded by the blockchain network, verify the execution status of the task allocation and resource scheduling based on a smart contract, and trigger a fault self-healing process to re-allocate tasks when a node failure is detected.

[0015] In a third aspect, the invention provides the following technical solution. A computer device includes a memory, a processor, and a computer program stored on the memory and executable on the processor. When the processor executes the computer program, the above-mentioned distributed integration optimization method for a low-latency and highly reliable cloud collaborative computer system is implemented.

[0016] In a fourth aspect, the invention provides the following technical solution. A readable storage medium stores a computer program, and when the computer program is executed by a processor, the above-mentioned distributed integration optimization method for a low-latency and highly reliable cloud collaborative computer system is implemented.

[0017] The invention has the following beneficial effects: 1. In the invention, by integrating DQN, FedProx, and blockchain technologies, the coordination of task allocation, resource optimization, and fault self-healing is realized. The three are linked by sharing node state data to optimize the performance of the cloud system, and the problems of the separation of task allocation and resource scheduling and the low fault recovery efficiency in the traditional cloud system are solved.

[0018] 2. In the invention, through Dueling DQN, the task allocation is dynamically optimized to adapt to network changes. S101 collects node state data, S102 constructs a state space, and S103 trains DQN to output an allocation strategy, which can accurately respond to latency and load fluctuations and is superior to static allocation.

[0019] 3. In the invention, FedProx is adopted to realize distributed resource optimization. S201 trains a local model, S202 aggregates to generate a resource allocation strategy, and S203 adjusts resources. By combining GNN and using the network topology, the resource utilization efficiency is improved.

[0020] 4. In the invention, fault self-healing is realized through blockchain smart contracts. S301 obtains logs, S302 verifies the state, and S303 calls DQN to reallocate tasks. The distributed ledger ensures reliability and is superior to traditional manual recovery. BRIEF DESCRIPTION OF THE DRAWINGS

[0021] Figure 1 It is the overall method flowchart of the distributed integration optimization method for a low-latency and highly reliable cloud collaborative computer system proposed by the invention; Figure 2 It is the DQN algorithm flowchart of the distributed integration optimization method for a low-latency and highly reliable cloud collaborative computer system proposed by the invention; Figure 3 It is the FedProx algorithm flowchart of the distributed integration optimization method for a low-latency and highly reliable cloud collaborative computer system proposed by the invention; Figure 4Flowchart of blockchain self-healing for the distributed integration optimization method of the low-latency and high-reliability cloud-edge collaborative computer system proposed by the present invention; Figure 5 Flowchart of the GNN algorithm for the distributed integration optimization method of the low-latency and high-reliability cloud-edge collaborative computer system proposed by the present invention. Detailed implementation manners

[0022] Next, the technical solutions in the embodiments of the present invention will be clearly and completely described with reference to the accompanying drawings. Obviously, the described embodiments are only a part of the embodiments of the present invention, rather than all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those of ordinary skill in the art without creative efforts shall fall within the protection scope of the present invention.

[0023] Embodiment 1 Referring to Figures 1-5 , in the first embodiment of the present invention, the present invention provides a distributed integration optimization method for a low-latency and high-reliability cloud-edge collaborative computer system, which is applied to a server and includes the following steps: S1. Obtain the node status data of multiple cooperative nodes, process the node status data based on a reinforcement learning model, and generate a task allocation policy and a data routing policy; S2. Receive the local resource optimization parameters generated by each cooperative node based on federated learning, aggregate the local resource optimization parameters to generate a global resource allocation policy, and send the global resource allocation policy to each cooperative node to coordinate resource allocation; S3. Obtain the task allocation log and resource scheduling log recorded in the blockchain network, verify the execution status of task allocation and resource scheduling based on a smart contract, and trigger a fault self-healing process when a node failure is detected to re-allocate tasks.

[0024] Specifically, in step S1, the node status data includes network latency (in milliseconds, representing the transmission speed), computing load (expressed as CPU / GPU utilization rate, reflecting the processing ability), node reliability (a probability value based on the historical failure frequency, evaluating the stability), and bandwidth (in Mbps, measuring the network capacity). The data is collected by a monitoring agent and transmitted to the server after encryption. The reinforcement learning model adopts a deep Q-network (DQN), the input is a node status vector (including latency, load, reliability, etc.), and the output is a task allocation policy (the mapping of task ID and node ID, such as allocating real-time tasks to edge nodes) and a data routing policy (the data transmission path, such as through a high-bandwidth link). The DQN algorithm optimizes cloud task allocation, the state space includes node status and task requirements (task computing volume or latency requirements), the action space is allocation and routing selection, and the reward function is , and the weights α and β are dynamically adjusted according to the task priority. The DQN pseudocode is as follows: Function DQN_Train(states, actions, rewards, next_states): Initialize the Q-network Q(s, a; θ) and the target network Q'(s, a; θ'). Initialize the experience replay buffer D For each episode: Obtain the current state s (node state vector, e.g., {delay, load}) Select an action a (task assignment or routing) using the ε-greedy policy Execute the action a, observe the reward r (based on delay and reliability), and enter the next state s'. Store (s, a, r, s') in D Sample a mini-batch of samples from D Calculate the target Q-value: y = r + γ * max(Q'(s', a'; θ')) Update the Q-network: Minimize the loss L = (y - Q(s, a; θ))^2 Periodically update the target network θ' ← θ Return the optimized Q-network.

[0025] Parameter Explanation: states: Node state vector, including delay, load, etc., representing the cloud network environment.

[0026] actions: Task assignment (task to node) or routing (data path), driving system optimization.

[0027] rewards: Reward function value, combining delay (negative) and reliability (positive), guiding learning.

[0028] θ, θ': Q-network and target network parameters, controlling policy generation.

[0029] γ: Discount factor, balancing short-term and long-term rewards.

[0030] ε: Exploration rate, controlling the proportion of random actions.

[0031] In step S2, federated learning uses the FedProx algorithm. The input is local load data (including computational load and task response requirements), and the output is local resource optimization parameters (neural network weights). The server aggregates to generate a global resource allocation policy (allocating CPU, memory, and bandwidth to nodes). FedProx optimizes resource allocation and reduces conflicts. The FedProx pseudocode is as follows: Function FedProx_Train(local_data, global_model): Initialize the global model \(w_g\) For each training round: Distribute \(w_g\) to each node For each node \(i\) in parallel: Train the local model using local data (load, task requirements) Calculate the local loss \(L_i(w)+\frac{\mu}{2}\|w - w_g\|^2\) Update the local weight \(w_i\) Collect \(w_i\) from each node Aggregate the global model: \(w_g\leftarrow\frac{\sum(w_i)}{N}\) Return the global model \(w_g\) Parameter explanation: local_data: Local load data, such as CPU utilization, driving resource optimization.

[0032] global_model: Global model weight, coordinating node resource allocation.

[0033] \(\mu\): Regularization coefficient, controlling the consistency between the local model and the global model.

[0034] N: Number of nodes, affecting the aggregated weight.

[0035] In step S3, the blockchain network is based on Hyperledger Fabric. Inputting the task assignment log (task ID, node, time) and resource scheduling log (resource type, allocation amount), it outputs the verification result (a boolean value indicating the compliance of the service level agreement). The smart contract verifies the latency and reliability, and for self-healing, it reallocates tasks by calling DQN. Algorithm interaction: DQN depends on the resource policy of FedProx to select nodes, and the blockchain logs record the execution results, which are fed back to DQN to adjust the reward function, optimizing task assignment, resource management, and fault recovery.

[0036] Step S1 includes: S101, Obtain the network latency, computing load, node reliability, and data transmission bandwidth of the collaborative nodes through the monitoring agent, and generate node status data; S102, Based on the node status data, construct a reinforcement learning model. The state space of the reinforcement learning model includes node status, task requirements, and network topology, the action space includes task assignment and data routing, and the reward function is defined as:

[0037] Wherein, R is the reward value, used to evaluate the pros and cons of the task allocation strategy and the data routing strategy; α is the weight coefficient of latency, adjusting the impact of latency on the reward value; Latency is the latency of task execution, in milliseconds; β is the weight coefficient of reliability, adjusting the impact of reliability on the reward value; Reliability is the reliability of the node, ranging from 0 to 1; S103. Use the deep Q network to train the reinforcement learning model to generate the task allocation strategy and the data routing strategy.

[0038] Specifically, in step S101, the monitoring agent collects node status data, with the inputs being network latency (measured by TCP probes), computing load (obtained by cgroups), node reliability (based on failure records), and bandwidth (NetFlow statistics), and the output being a status vector in JSON format (including node ID, latency, load, etc.). In step S102, the reinforcement learning model uses Dueling DQN, with the input being the node status vector (including latency, load, and task computing volume), and the outputs being the task allocation action (task to node, such as real-time task to edge node) and the routing action (data path, such as low-latency link). The state space includes the cloud network topology, the action space is the combination of allocation and routing, and the reward function is . Dueling DQN optimizes cloud task scheduling, and the weights α and β are adjusted according to the task type. The pseudo-code of Dueling DQN is as follows: Function Dueling_DQN_Train(states, actions, rewards, next_states): Initialize the Q network Q(s,a;θ)=V(s;θ)+A(s,a;θ) Initialize the target network Q'(s,a;θ') Initialize the experience replay buffer D For each episode: Obtain the state s (node status vector, such as {latency, load, task demand}) Select the action a (task allocation or routing) using ε-greedy Execute the action a, observe the reward r, and enter the state s' Store (s,a,r,s') into D Sample a small batch of samples Calculate the target: y=r+γ*max(Q'(s',a';θ')) Update the Q network: minimize L=(y - Q(s,a;θ))^2 Periodically update the target network θ'←θ Return the optimized Q network.

[0039] Parameter explanation: V(s;θ): The state value function, which evaluates the overall value of the node state.

[0040] A(s,a;θ): The action advantage function, which evaluates the relative advantages and disadvantages of the allocation or routing actions.

[0041] states, actions, rewards: Similar to DQN, driving the optimization of cloud tasks.

[0042] γ, ε: Controlling the learning stability and exploration.

[0043] In step S103, experience replay is used for training. The state-action pairs are input, and the optimized policy is output. Dueling DQN interacts with the monitoring data: the state vector drives the action selection, and the execution result feeds back to update the model, improving the allocation efficiency.

[0044] The monitoring agent in step S101 collects the node state data at a cycle of once per second to adapt to the dynamic load changes.

[0045] Specifically, the monitoring agent collects the node state data at a 1-second cycle. The inputs are network latency (obtained by UDP probes), computing load (obtained by system APIs), and node reliability (based on fault records), and the output is time series data (including timestamps, node IDs, and status fields). The cycle is implemented by a high-precision timer. The collected data drives the update of the task allocation policy of Dueling DQN to adapt to dynamic load changes (such as sudden increase in network traffic). In cloud collaborative computing, the 1-second cycle ensures that the task allocation responds to the network state changes. The state data is input into Dueling DQN to generate an optimized allocation (such as allocating real-time tasks to edge nodes), maintaining low latency and high reliability to meet the needs of unmanned driving navigation.

[0046] Step S2 includes: S201, receiving the local resource optimization parameters trained by each collaborative node based on local load and task requirements. The local resource optimization parameters are added with noise through differential privacy technology to protect data privacy; S202, aggregating the local resource optimization parameters through a secure aggregation protocol to generate a global resource allocation policy; S203, sending the global resource allocation policy to each collaborative node to trigger the collaborative nodes to adjust the allocation of computing resources, storage, and bandwidth.

[0047] Specifically, in step S201, Federated Learning uses FedProx. The input is local load data (CPU utilization, task response time requirements), and the output is local model weights (weight vectors). The model is a Multi-Layer Perceptron (MLP), and noise is added through differential privacy; the FedProx pseudocode has been written above. In step S202, Secure Aggregation uses homomorphic encryption. The input is encrypted weights, and the output is the global resource allocation policy (node CPU, memory, bandwidth allocation). FedProx optimizes cloud resource allocation and reduces conflicts. In step S203, the policy is sent down through a low-latency protocol to trigger nodes to adjust resources. FedProx interacts with Dueling DQN: the global resource policy guides DQN to select task execution nodes, optimizing resource utilization and latency.

[0048] The training of local resource optimization parameters is based on node status data, and the output of the global resource allocation policy includes the resource allocation schemes for each collaborative node.

[0049] Specifically, the training of local resource optimization parameters is based on node status data. The input is a feature vector (latency, load, reliability), and the output is a resource allocation vector (number of CPU cores, memory, bandwidth). The model is a Graph Neural Network (GNN), which optimizes cloud resource allocation through message passing. The GNN pseudocode is as follows: Function GNN_Train(graph,node_features): Initialize the GNN model G(v;θ) For each training round: For each node v in the graph: Collect neighbor node features h_u Aggregate neighbor information: h_v'=Σ(h_u) / |N(v)| Update node features: h_v=σ(W*[h_v,h_v']+b) Calculate the loss L = MSE(h_v,target_allocation) Update the model parameters θ Return the optimized GNN model.

[0050] Parameter Explanation: graph: Cloud network topology, where nodes are servers / edge nodes and edges are network connections.

[0051] node_features: Node status, such as latency and load, driving resource allocation.

[0052] h_v: Node feature vector representing resource requirements.

[0053] W, b: Model weights and biases that control feature updates.

[0054] σ: Activation function (such as ReLU) that introduces non-linearity.

[0055] Interaction between GNN and FedProx: Node states are input into the GNN to generate local parameters, and FedProx aggregates them to generate a global policy and outputs a resource allocation plan, improving resource utilization efficiency.

[0056] Step S3 includes: S301, Obtain the task assignment log and resource scheduling log recorded in the distributed ledger of the blockchain network; S302, Verify through the service level agreement contract whether the execution of task assignment and resource scheduling meets the latency and reliability requirements; S303, When a node failure is detected, trigger the contract to call the reinforcement learning model through self-healing, generate a new task assignment policy, and reassign tasks to highly reliable nodes. The execution time of the fault self-healing process is controlled within 100 milliseconds.

[0057] Specifically, in step S301, the blockchain network is based on Tendermint. Input the task assignment log (task ID, execution node) and resource scheduling log (resource type, allocation volume), and output a hash index. In step S302, the SLA verification contract inputs the log data and outputs the verification result (a boolean value indicating compliance with latency and reliability). In step S303, the fault detection inputs heartbeat data and outputs a fault signal. The self-healing contract calls Dueling DQN, inputs the network state and fault information, and outputs a new allocation policy. Interaction between the blockchain and DQN: The log verification result feeds back to DQN to adjust the policy and optimize system continuity.

[0058] The task assignment policy, global resource allocation policy, and fault self-healing process are linked by sharing node state data, where: S4, The global resource allocation policy optimizes resource allocation based on node state data; S5, The task assignment policy selects an execution node according to the global resource allocation policy; S6, The blockchain network uses the practical Byzantine fault tolerance consensus mechanism to record the execution logs of the task assignment policy and the global resource allocation policy.

[0059] Specifically, in step S4, the global resource allocation policy uses dynamic programming. Input the node state data (latency, load), and output a resource allocation plan. The dynamic programming pseudocode is as follows: Function Dynamic_Programming(states,constraints): Initialize the state table DP[s,r] For each state s (node state, such as {delay, load}): For each resource r (CPU, memory, bandwidth): Calculate the allocation cost c = w1 * Latency + w2 * (1 - Reliability) Update DP[s,r] = min(DP[s',r'] + c) Return the optimal allocation scheme.

[0060] Parameter explanation: states: Node state, driving resource allocation.

[0061] constraints: Resource upper limit, such as the number of CPU cores, restricting allocation.

[0062] w1, w2: Weights, balancing delay and reliability.

[0063] In step S5, the task allocation strategy uses A* search, takes the resource scheme as input, and outputs the allocation action. The A* pseudocode is as follows: Function A_Star_Search(start_state, goal): Initialize the open list open_list and the closed list closed_list Add start_state to open_list While open_list is not empty: Select the node n with the minimum f(n) = g(n) + h(n) If n is the goal state, return the allocation path Move n to closed_list For each neighbor m of n: Calculate g(m) = g(n) + allocation cost Calculate h(m) = estimated delay If m is not in open_list or has a lower f(m), update m Return the optimal allocation.

[0064] Parameter explanation: start_state: Initial node state, including task requirements.

[0065] goal: Target allocation state, meeting task requirements.

[0066] g(n): Cumulative allocation cost, based on resource usage.

[0067] h(n): Heuristic estimate, based on delay prediction.

[0068] In step S6, the PBFT consensus inputs the execution log and outputs a consistency record. The PBFT pseudocode is as follows: Function PBFT_Consensus(log): Initialize the primary node P and the replica nodes R The primary node P broadcasts a pre-prepare message <log, view> For each replica R: Verify the pre-prepare message and broadcast a prepare message If enough prepare messages are received, broadcast a commit message If enough commit messages are received, record log to the ledger Return the consistency result.

[0069] Parameter explanation: log: The task or resource log to be verified by consensus.

[0070] view: The current view, identifying the primary node.

[0071] Algorithm interaction: The resource scheme of dynamic programming guides A* to select nodes, and PBFT records the results and feedbacks to dynamic programming to optimize the task execution efficiency.

[0072] Embodiment 2: In the second embodiment of the present invention, the present invention provides a distributed integration optimization system for a low-latency and high-reliability cloud collaborative computer system, including: A data processing module configured to obtain the node status data of multiple collaborative nodes, process the node status data based on a reinforcement learning model, and generate a task allocation policy and a data routing policy; A resource optimization module configured to receive the local resource optimization parameters generated by each collaborative node based on federated learning, aggregate the local resource optimization parameters to generate a global resource allocation policy, and send the global resource allocation policy to each collaborative node; A verification and self-healing module configured to obtain the task allocation log and resource scheduling log recorded in the blockchain network, verify the execution status of task allocation and resource scheduling based on a smart contract, and trigger a fault self-healing process when a node failure is detected to re-allocate tasks.

[0073] Specifically, the system includes a high-performance processor and memory, and the program is in a microservices architecture. In step S1, Dueling DQN inputs the node state vector and outputs the task allocation and routing policy. In step S2, FedProx inputs the local weights and outputs the global resource allocation policy. In step S3, Tendermint blockchain inputs the logs and outputs the verification results. The algorithms interact through a shared cache: DQN uses the resource policy of FedProx, and the blockchain feedback results optimize the DQN allocation to achieve low latency and high reliability.

[0074] Embodiment 3 In the third embodiment of the present invention, based on the same inventive concept, a computer-readable storage medium is proposed. The computer-readable storage medium stores a computer program, and when the computer program is executed by a processor, it implements the steps of the low-latency and high-reliability cloud collaborative computer system distributed integration optimization method of the above embodiment.

[0075] Embodiment 4 In the fourth embodiment of the present invention, based on the same inventive concept, a computer device is proposed, including: a processor and a memory; the processor and the memory communicate with each other; the memory is used to store instructions; the processor is used to execute the instructions in the memory to execute the low-latency and high-reliability cloud collaborative computer system distributed integration optimization method of the above embodiment.

[0076] It should be understood that each part of the present invention can be implemented by hardware, software, firmware, or a combination thereof. In the above embodiments, multiple steps or methods can be implemented by software or firmware stored in a memory and executed by a suitable instruction execution system. For example, if implemented by hardware, as in another embodiment, any one or a combination of the following well-known technologies in the art can be used: discrete logic circuits with logic gate circuits for implementing logical functions on data signals, application-specific integrated circuits with appropriate combinational logic gate circuits, programmable gate arrays (PGAs), field programmable gate arrays (FPGAs), etc.

[0077] Finally, it should be noted that the above are only the preferred embodiments of the present invention and are not used to limit the present invention. Although the present invention has been described in detail with reference to the foregoing embodiments, for those skilled in the art, they can still modify the technical solutions described in the foregoing embodiments, or perform equivalent replacements on some of the technical features. Any modifications, equivalent replacements, improvements, etc. made within the spirit and principle of the present invention shall be included in the protection scope of the present invention.

Claims

1. A distributed integration optimization method for a low-latency and high-reliability cloud-edge collaborative computer system, applied to a server, characterized in that It includes the following steps: S1. Obtain the node status data of multiple collaborative nodes, process the node status data based on a reinforcement learning model, and generate a task allocation policy and a data routing policy; S2. Receive the local resource optimization parameters generated by each collaborative node based on federated learning, aggregate the local resource optimization parameters to generate a global resource allocation policy, and send the global resource allocation policy to each collaborative node to coordinate resource allocation; S3. Obtain the task allocation log and resource scheduling log recorded in the blockchain network, verify the execution status of the task allocation and resource scheduling based on a smart contract, and trigger a fault self-healing process to reallocate tasks when a node failure is detected.

2. The distributed integration optimization method for the low-latency and high-reliability cloud collaborative computer system according to claim 1, wherein, The step S1 includes: S101. Obtain the network latency, computing load, node reliability, and data transmission bandwidth of the collaborative nodes through a monitoring agent, and generate the node status data; S102. Based on the node status data, construct a reinforcement learning model. The state space of the reinforcement learning model includes node status, task requirements, and network topology. The action space includes task allocation and data routing. The reward function is defined as: ； where R is the reward value used to evaluate the pros and cons of the task allocation policy and the data routing policy; α is the weight coefficient of latency, adjusting the impact of latency on the reward value; Latency is the latency of task execution in milliseconds; β is the weight coefficient of reliability, adjusting the impact of reliability on the reward value; Reliability is the reliability of the node, ranging from 0 to 1; S103. Use a deep Q-network to train the reinforcement learning model to generate the task allocation policy and the data routing policy.

3. The distributed integration optimization method for the low-latency and high-reliability cloud collaborative computer system according to claim 2, wherein The monitoring agent in the step S101 collects the node status data at a frequency of once per second to adapt to dynamic load changes.

4. The distributed integration optimization method for the low-latency and high-reliability cloud collaborative computer system according to claim 2, wherein The step S2 includes: S201. Receive the local resource optimization parameters trained by each collaborative node based on local load and task requirements. The local resource optimization parameters are added with noise through differential privacy technology to protect data privacy; S202. Aggregate the local resource optimization parameters through a secure aggregation protocol to generate the global resource allocation policy; S203. Send the global resource allocation policy to each collaborative node to trigger the collaborative node to adjust the allocation of computing resources, storage, and bandwidth.

5. The distributed integration optimization method for the low-latency and high-reliability cloud-edge collaborative computer system according to claim 4, wherein The training of the local resource optimization parameters is based on the node status data, and the output of the global resource allocation policy includes the resource allocation scheme of each collaborative node.

6. The distributed integration optimization method for the low-latency and high-reliability cloud collaborative computer system according to claim 2, wherein The step S3 includes: S301. Obtain the task allocation log and resource scheduling log recorded in the distributed ledger of the blockchain network; S302. Verify whether the execution of the task allocation and resource scheduling meets the latency and reliability requirements through a service level agreement contract verification; S303. When a node failure is detected, call the reinforcement learning model through a self-healing trigger contract to generate a new task allocation policy, and reallocate tasks to high-reliability nodes. The execution time of the fault self-healing process is controlled within 100 milliseconds.

7. The distributed integration optimization method for the low-latency and high-reliability cloud collaborative computer system according to claim 1, wherein The task allocation strategy, the global resource allocation strategy, and the fault self-healing process are linked by sharing the node status data, where: S4. The global resource allocation strategy optimizes resource allocation based on the node status data; S5. The task allocation strategy selects execution nodes according to the global resource allocation strategy; S6. The blockchain network uses the practical Byzantine fault tolerance consensus mechanism to record the execution logs of the task allocation strategy and the global resource allocation strategy.

8. A distributed integration optimization system for a low-latency and high-reliability cloud collaborative computer system, characterized in that, For the low-latency and high-reliability cloud collaborative computer system distributed integration optimization method according to any one of claims 1-7, the system includes: A data processing module configured to obtain the node status data of multiple cooperative nodes, process the node status data based on a reinforcement learning model, and generate a task allocation strategy and a data routing strategy; A resource optimization module configured to receive the local resource optimization parameters generated by each cooperative node based on federated learning, aggregate the local resource optimization parameters to generate a global resource allocation strategy, and send the global resource allocation strategy to each cooperative node; A verification and self-healing module configured to obtain the task allocation log and the resource scheduling log recorded by the blockchain network, verify the execution status of the task allocation and the resource scheduling based on a smart contract, and trigger a fault self-healing process when a node failure is detected to re-allocate tasks.

9. A computer device, comprising a memory, a processor, and a computer program stored on the memory and executable on the processor, characterized in that, When the processor executes the computer program, it implements the low-latency and high-reliability cloud collaborative computer system distributed integration optimization method according to any one of claims 1 to 7.

10. A readable storage medium, characterized in that, A computer program is stored on the readable storage medium, and when the computer program is executed by the processor, it implements the low-latency and high-reliability cloud collaborative computer system distributed integration optimization method according to any one of claims 1 to 7.

Images