A method and system for dynamic resource allocation in a distributed system of a thermal power plant

Abstract

This invention provides a method and system for dynamic resource allocation in a distributed system of a thermal power plant. It acquires local time-series data and resource-related event data, constructs an ordered time algebra system, outputs an asynchronous alignment graph and a time-series alignment operator, builds a causal separation architecture and obtains resource classification results, synchronously constructs a hierarchical consensus topology, performs consensus evolution in conjunction with the asynchronous alignment graph, acquires alignment time information, constructs a state machine algebra and obtains a resource allocation strategy, uses a remapping strategy to obtain remapping allocation data, acquires node state data and corrects the node state data based on the remapping allocation data, obtains corrected node state data, and obtains the resource allocation result through alignment time information, resource allocation strategy, and corrected node state data. This dynamic resource allocation scheme for a distributed system of a thermal power plant solves the problem of poor resource allocation adaptability, thereby improving the accuracy of resource allocation in the distributed system of a thermal power plant.

Description

Technical Field

[0001] This invention relates to the field of industrial communication, and more specifically, to a method and system for dynamic allocation of resources in a distributed system of a thermal power plant. Background Technology

[0002] With the deep integration of intelligent manufacturing and the energy internet, the operating systems of thermal power plants are becoming increasingly complex, and the coverage of distributed architectures is continuously expanding. This places increasingly stringent requirements on the time-series consistency, characteristic adaptability, and dynamic responsiveness of resource allocation. However, the resource allocation process in thermal power plant distributed systems is characterized by multi-node time-series deviations, significant differences in the causal characteristics of resource types, and dynamic changes in scenario operating patterns. Currently, existing resource allocation solutions for thermal power plant distributed systems focus on integrating multi-node resource data, streamlining resource allocation logic, adapting to different operating scenarios, and achieving resource scheduling. However, existing technologies often struggle to meet the needs of real-world scenarios.

[0003] On the one hand, existing technologies in time series processing mostly calibrate local time series data of a single node, failing to achieve deep integration and global alignment of time series data from multiple nodes. Furthermore, they cannot adaptively identify causal dependencies in resource allocation, which can easily lead to time series confusion or causal conflicts, resulting in a lack of reliable time benchmarks and logical support for subsequent resource allocation. On the other hand, the resource scheduling adaptation logic is one-sided. Existing technologies mostly adopt a unified scheduling strategy to deal with resources with different causal characteristics, without combining a hierarchical adaptation mechanism. This makes it difficult to balance the real-time requirements of strong causal resources with the utilization requirements of weak causal resources, leading to resource allocation failures or inefficient utilization, and making it difficult to ensure the stable operation of distributed systems in thermal power plants.

[0004] Therefore, there is an urgent need for a dynamic resource allocation scheme for distributed systems in thermal power plants that features adaptive timing alignment, causal hierarchical adaptation, node state correction, and dynamic scenario response, in order to solve the problem of poor adaptability of resource allocation in existing technologies and thus improve the accuracy of resource allocation in distributed systems of thermal power plants. Summary of the Invention

[0005] In view of the aforementioned problems, and in conjunction with the first aspect of the present invention, embodiments of the present invention provide a method for dynamic allocation of resources in a distributed system of a thermal power plant, the method comprising:

[0006] Acquire local time-series data and resource-related event data from each computing node and construct an ordered time algebra system, outputting an asynchronous alignment graph and a time-series alignment operator;

[0007] Construct a causal separation architecture based on time-series alignment operator updates and obtain resource classification results. Simultaneously construct a hierarchical consensus topology and combine it with an asynchronous alignment graph to perform consensus evolution and obtain alignment time information.

[0008] Based on resource allocation requirements and resource classification results, a state machine algebra for resource allocation is constructed and a resource allocation strategy is obtained. A remapping strategy based on drift jitter data and resource allocation strategy is adopted to obtain remapping allocation data.

[0009] Node state data is obtained based on asynchronous alignment graph and corrected by combining remapping and allocation data to obtain corrected node state data;

[0010] Based on alignment time information, resource allocation strategy, and correction node status data, the resource allocation result is obtained.

[0011] Furthermore, embodiments of the present invention also provide a dynamic resource allocation system for a distributed system in a thermal power plant, comprising:

[0012] The acquisition module is used to acquire local time-series data and resource-related event data of each computing node;

[0013] The construction module is used to construct an ordered time algebra system, construct a causal separation architecture and obtain resource classification results, construct a hierarchical consensus topology, construct a state machine algebra for resource allocation and obtain resource allocation strategies;

[0014] The processing module obtains the asynchronous alignment graph and time-series alignment operator based on the ordered time algebra system, and obtains the resource allocation result based on the alignment time information, resource allocation strategy and correction node state data;

[0015] An evolution module is used to perform consensus evolution on the consensus topology and obtain alignment time information;

[0016] The mapping module uses a remapping strategy based on drift jitter data and resource allocation strategy to obtain remapping allocation data;

[0017] The correction module obtains node state data based on the asynchronous alignment graph and corrects the node state data by combining it with remapping allocation data, thereby obtaining corrected node state data. Attached Figure Description

[0018] Figure 1 This is a flowchart of the steps of a method for dynamic allocation of resources in a distributed system of a thermal power plant according to the present invention;

[0019] Figure 2 This is a flowchart of the steps for obtaining resource classification results in a method for dynamic allocation of resources in a distributed system of a thermal power plant according to the present invention. Detailed Implementation

[0020] The present invention will be further described in detail below through specific embodiments. The following embodiments are merely descriptive and not limiting, and should not be used to limit the scope of protection of the present invention.

[0021] like Figure 1 and Figure 2 As shown, a method for dynamic resource allocation in a distributed system of a thermal power plant includes the following steps:

[0022] Step A: Obtain local time-series data and resource-related event data for each computing node, construct an ordered time algebra system, and output an asynchronous alignment graph and a time-series alignment operator.

[0023] Step A includes:

[0024] Step A-1, the computing nodes include field control nodes, module coordination nodes and global coordination nodes in the distributed control system of thermal power plants.

[0025] It should be noted that the computing nodes are units in the distributed control system of thermal power plants used for resource processing, data interaction, and command execution. Different types of nodes have clear division of labor and work together. Field control nodes directly connect to field equipment, are responsible for collecting equipment operation data in real time and executing low-level control commands. Module coordination nodes are responsible for coordinating multiple field control nodes within a certain functional module to realize resource scheduling and data aggregation within the module. Global coordination nodes are oriented towards the entire distributed system and are used to coordinate cross-module resources, formulate global strategies, and manage system status.

[0026] For example, in a boiler combustion control system, field control nodes include furnace temperature control nodes, furnace pressure control nodes, and burner start-up and shutdown control nodes, which are respectively connected to the corresponding temperature sensors, pressure sensors, and burner actuators; module coordination nodes are burner group coordination nodes, which coordinate the field control nodes corresponding to multiple burners and coordinate the start-up and shutdown sequence and load distribution of each burner; global coordination nodes are boiler combustion global optimization nodes, which are responsible for coordinating the resource allocation of burner group coordination nodes and other related functional module nodes in combination with unit load demand, environmental emission requirements, etc.

[0027] Step A-2: Obtain local time-series data and resource-related event data through the data acquisition modules of each computing node. The resource-related event data includes resource request data, resource release data, and resource state transition event data.

[0028] Specifically, in the distributed control system of a thermal power plant, each computing node is equipped with a data acquisition module, which has the functions of real-time data acquisition, format standardization, and local caching. Local time-series data is time-series data generated by the node through local clock data, used to mark the timestamps of various events, providing a basic time reference for subsequent time-series alignment. Resource-related event data includes resource request data, resource release data, and resource state transition event data. Among them, resource request data is information related to the node's request for resources from the system, including the requested resource type, quantity, priority, etc. Resource release data is a record of the node releasing the occupied resources after completing the task. Resource state transition event data is event information of the resource changing from one state to another. Resource states include idle, occupied, fault, etc.

[0029] In some possible embodiments, in the boiler combustion control system, the data acquisition module of each field control node collects local clock data every 10ms to generate local timing data; when the burner start-stop control node needs to execute a start-stop command, it sends resource request data to the system, including requesting a strong causal resource, having the highest priority, and a request timestamp T1; when a burner completes a start-stop task, the node sends resource release data, including releasing a strong causal resource, a release timestamp T2, and a resource occupation duration ΔT; when a weak causal resource changes from an idle state to an occupied state by a combustion state monitoring node, resource state transition event data is generated, recording the resource type as a weak causal resource, the original state as idle, the new state as occupied, the transition timestamp T3, and the triggering node as a combustion state monitoring node.

[0030] Step A-3: Based on local time series data and resource-related event data, obtain the local time manifold of each node, and construct an ordered time algebra system based on the local time manifold.

[0031] Specifically, by extracting local timestamp sequences, the PC algorithm can be used to logically deduce resource-related events, obtaining the causal sequence of events, such as resource request events preceding resource allocation events, and concurrent relationships of events without logical dependencies, such as resource request events from two different burners. This allows the acquisition of the local time manifold of each node, specifically represented as Ti = (τi, <i, ~i), where i represents the index identifier of the computing node, τi represents the timestamp sequence extracted from local time-series data, <i represents the causal sequence of events, and ~i represents the concurrent relationship of events. Furthermore, using the local time manifolds of all computing nodes as input, and through event interaction data between nodes, such as instruction transmission and status reporting data, an association mapping of the local time manifolds of different nodes is established. This clarifies the timestamp correspondence between τi and τj, the causal compatibility rules between <i and <j, and the fusion logic of the concurrent relationship between ~i and ~j. The system's basic set, operational rules, and constraints are defined, thereby integrating the dispersed local time manifolds into an algebraic structure.

[0032] It should be noted that the ordered temporal algebraic system is specifically a model that integrates local temporal manifolds. This model includes an input layer, an integration layer, an algebraic layer, and an output layer. The input layer takes into account the set of local temporal manifolds of each computing node. The integration layer standardizes and integrates the scattered local temporal manifolds of the input layer to form a unified dataset of time series and event associations. The algebraic layer transforms the integrated dataset into a computationally achievable algebraic system by defining algebraic structures and operational rules. The output layer is used to output asynchronous alignment graphs and time series alignment operators.

[0033] Furthermore, the integration layer includes an association mapping module, a relationship fusion module, and a conflict filtering module. The association mapping module establishes a mapping relationship between the local time manifolds of different nodes through node interaction data. For example, it establishes a timestamp mapping function between burner node τ1 and coordinating node τ2 based on the command interaction delay between the burner start / stop control node and the burner group coordination node, ensuring that timestamps of different nodes can be associated across nodes. The relationship fusion module fuses the causal and concurrent relationships between different nodes. For example, if node i has i A <i B Node j exists C <j D A and B are both event index identifiers within a computing node, and i A With j C If there is an interactive dependency, then it is merged into (i A ,j CThe system establishes the causal relationships between nodes; the conflict filtering module filters out conflict relationships generated during the integration process, such as reverse causality and invalid concurrency, through the operating logic of the distributed system of the thermal power plant, such as the causal constraints of control command execution, and outputs a standardized integrated dataset; the algebraic layer needs to first define the basic algebraic elements of the system, defined as M=(S,O,P), where S is the standardized integrated dataset output by the integration layer, O is the set of operation rules, and P is the set of constraint conditions; define operation rules, including operation ∪, used to fuse time segments of different nodes, such as ∪(τ1,τ2) to obtain the joint timestamp sequence of nodes 1 and 2; product operation × is used to associate the event relationships of different nodes, such as ×(<1,<2) to obtain the causal relationship between nodes 1 and 2; mapping operation · is used for cross-node time alignment, such as i A ·j C This indicates that events A at node i and C at node j can be aligned using a mapping function; simultaneously, a set of constraints P is defined, including causality-preserving constraints, if i A <i B After mapping, the causal relationship is still satisfied, that is, the timestamp of event A is still earlier than the timestamp of time B after the mapping of node i, and the bounded distortion constraint is also satisfied. Specifically, the cross-node timestamp mapping deviation is less than a preset threshold. The preset threshold is set according to the business's need for timing accuracy. For nodes with strong causal resource correlation, it can be set to 0.5ms, and for nodes with weak causal resource correlation, it can be set to 5ms. For example, the mapping deviation between the burner node and the coordination node is less than the set value of 0.5ms.

[0034] In some possible embodiments, taking the burner start-stop control node as an example, the timestamp sequence τ1=[T1,T2,T3,...] is extracted based on its local time series data. Combined with resource-related event data, the causal order of resource request event (T1) < resource allocation event (T2) and resource allocation event (T2) < resource release event (T3) is derived, as well as the concurrency relationship of burner 1 start-stop resource request event (T1) to burner 2 start-stop resource request event (T1'). The local time manifold of this node is then constructed. Similarly, the local time manifolds of other nodes such as burner group coordination node and global coordination node are constructed. Then, the local time manifolds of all nodes are integrated to construct the ordered time algebraic system of the boiler combustion control system.

[0035] Step A-4: Output the asynchronous alignment graph and the timing alignment operator based on the ordered time algebra system.

[0036] Specifically, an asynchronous alignment graph is generated by extracting the correlation relationships of the local time manifolds of each node in the ordered time algebra system. The asynchronous alignment graph is a graphical model representing the temporally alignable relationships between computing nodes, where the vertices of the graph are each computing node, the edges are the alignable relationships between nodes, and the weight of the edges is the maximum deviation threshold of the temporal alignment between nodes. A temporal alignment operator is defined by the causal preservation and bounded distortion constraints of events in the ordered time algebra system. That is, for any two events of nodes, if there exists a time mapping function that satisfies causal preservation and bounded distortion, then the temporal alignment operator is defined to hold. Cross-node timestamp mapping and alignment are achieved through the temporal alignment operator.

[0037] It should be noted that the weight of the edge is determined based on the interaction characteristics and operational requirements between nodes. Specifically, it is set comprehensively based on the frequency of event interaction between nodes, the range of data transmission delay jitter, and the requirements of the business for timing accuracy. The higher the interaction frequency and the stricter the business timing accuracy requirements, the smaller the weight value, that is, the smaller the allowable alignment deviation.

[0038] In some possible embodiments, taking the ordered time algebraic system of the boiler combustion control system as an example, the alignable relationships between each node are extracted to generate an asynchronous alignment graph, where the vertices are all calculation nodes such as the furnace temperature control node, the burner start-stop control node, and the burner group coordination node. There is an edge connection between the burner start-stop control node and the burner group coordination node, and the weight can be set to 0.5ms, indicating that the maximum deviation of the timing alignment between the two nodes does not exceed 0.5ms. The edge weight between the burner group coordination node and the global coordination node can be set to 2ms. At the same time, a timing alignment operator is generated. For event 1 (timestamp T1) of the burner start-stop control node and event 2 (timestamp T2) of the burner group coordination node, if there is a mapping function that satisfies that when the event corresponding to 1 precedes the event corresponding to 2, the mapped timestamp also satisfies that event 1 precedes event 2, and the deviation of the timing alignment between the two nodes is less than 0.5ms, then the timing alignment of the events of the two nodes is achieved.

[0039] Step B involves constructing a causal separation architecture based on time-series alignment operator updates and obtaining resource classification results. Simultaneously, a hierarchical consensus topology is constructed, and consensus evolution is performed in conjunction with the asynchronous alignment graph to obtain alignment time information.

[0040] Step B includes:

[0041] Step B-1: Obtain the attribute data of each resource in the distributed system of the thermal power plant. The attribute data includes the causal characteristics and functional types of the resources.

[0042] Specifically, the system resource survey and attribute acquisition module acquires attribute data of each resource in the distributed system of the thermal power plant. The attribute data includes the causal characteristics and functional types of the resources. The causal characteristics refer to the degree of dependence of the resource on the causal relationship of the event during the allocation and execution process, that is, whether there is a strict sequential logical constraint on the use of the resource, including strong causality, weak causality and mixed causality. The functional type refers to the specific business function undertaken by the resource. Resources with different functional types have differences in real-time performance, reliability and computing power requirements.

[0043] In some possible embodiments, in the boiler combustion control system, attribute data of various resources are acquired through the resource attribute acquisition module. For example, the causal characteristics of the burner start-stop control command execution resource are strong causality, which must strictly follow the causal sequence of request-allocation-execution-release, otherwise it will lead to burner malfunction. The function type is control command execution. The causal characteristics of the combustion status monitoring data analysis resource are weak causality, and the data analysis sequence can be flexibly adjusted. The function type is data processing. The causal characteristics of the combustion parameter optimization and adjustment resource are mixed causality, and the adjustment logic must follow the causal sequence. The auxiliary analysis can be flexibly adjusted. The function type is comprehensive optimization.

[0044] Step B-2: Based on the attribute data, build a causal separation architecture, classify resources, and obtain resource classification results.

[0045] Specifically, the causal separation architecture is a layered architecture model built through the causal characteristics of resources. It is used to achieve the isolation, allocation, and management of resources with different causal characteristics, ensuring the real-time performance and causal consistency of strong causal resources, while improving the utilization efficiency of weak causal resources. During the architecture construction process, different logical levels are divided according to the causal characteristics of resources, including the core level, non-core level, and intermediate adaptation level. Among them, strong causal resources correspond to the core level of the architecture and adopt a strict causal constraint mechanism; weak causal resources correspond to the non-core level of the architecture and adopt a resource scheduling mechanism; mixed resources correspond to the intermediate adaptation level and are layered and adapted in the architecture according to their causal strength coefficient. The system resources are divided into strong causal resources Rs, weak causal resources Rv, and mixed resources Rm=αRs⊕(1-α)Rv, where α is the causal strength coefficient, and ⊕ represents the weighted fusion operation, representing the proportion of strong causal characteristics in the mixed resources.

[0046] It should be noted that the resource scheduling mechanism specifically refers to dynamically allocating computing power through node load, allowing non-critical tasks to be executed in parallel, and utilizing system idle periods to process low-priority tasks, thereby improving the overall resource utilization rate. Hybrid resources can adopt a hybrid scheduling mechanism of strong core logic constraints and flexible auxiliary logic scheduling, that is, the scheduling priority is divided according to the causal intensity coefficient α. The core adjustment logic corresponding to the α proportion follows the strong causal scheduling rule, and the auxiliary analysis logic corresponding to the (1-α) proportion follows the weak causal scheduling rule. Furthermore, in this embodiment, the causal intensity coefficient α is set to 0.7. Taking the combustion parameter optimization and adjustment resource as an example, the hybrid resource ensures the accuracy and safety of combustion parameter adjustment. This adjustment logic is directly related to the stable control of key operating parameters such as furnace temperature and pressure, and must strictly follow the strong causal scheduling rule to avoid adjustment disorder. The auxiliary analysis logic does not affect the real-time control safety and can adopt weak causal flexible scheduling to improve resource utilization.

[0047] In some possible embodiments, a causal separation architecture is built based on the resource attribute data of the boiler combustion control system. The core layer is a strong causal resource layer, used to manage strong causal resources such as burner start-stop control command execution resources, employing a strict request-allocation-execution causal constraint mechanism. The non-core layer is a weak causal resource layer, used to manage weak causal resources such as combustion status monitoring data analysis resources, employing a resource scheduling mechanism. The intermediate adaptation layer is a hybrid resource layer, used to manage hybrid resources such as combustion parameter optimization and adjustment resources. Simultaneously, resource classification is completed: Rs = {burner start-stop control command execution resources, furnace pressure control command execution resources}, Rv = {combustion status monitoring data analysis resources, emission data statistical analysis resources}, Rm = 0.7Rs⊕0.3Rv, specifically including combustion parameter optimization and adjustment resources, such as furnace temperature-load matching optimization resources and combustion efficiency-emission collaborative optimization resources.

[0048] Step B-3: Collect the original resource state transition data and align the original resource state transition data using the time-series alignment operator to obtain the resource state transition data.

[0049] Specifically, the raw resource state transition data refers to the original record data of changes in the state of various resources during system operation. It can be collected in real time by the resource state monitoring module of each node, and its timestamp is generated by the local clock of the node. Due to the drift deviation of the clocks of each node, the timing of the raw data is not consistent. In order to ensure the accuracy of subsequent causal conflict detection, the raw resource state transition data needs to be time-aligned by combining the timing alignment operator. Specifically, the timing alignment operator maps the timestamps of the raw data collected by different nodes to a unified time base, eliminates the timing deviation caused by clock drift, and generates standardized resource state transition data.

[0050] It should be noted that this step uses the asynchronous alignment diagram generated in step A-4 to determine the mapping relationship between each node and the unified time base, including the clock drift correction direction; then, by calling the mapping operation of the ordered time algebra system through the timing alignment operator, the local timestamp is corrected in reverse according to the drift deviation to obtain the timestamp under the unified base.

[0051] In some possible embodiments, in the boiler combustion control system, raw resource status transition data is collected by the resource status monitoring module of each node. For example, the raw data of the burner start-stop control command execution resource is the change of status from idle to occupied, local timestamp T1, and node clock drift +0.2ms. The raw data of the combustion status monitoring data analysis resource is the change of status from occupied to idle, local timestamp T2, and node clock drift -0.1ms. The raw data is then aligned using the timing alignment operator obtained in step A, mapping T1 to T1'=T1-0.2ms under a unified time base, and mapping T2 to T2'=T2+0.1ms, thus obtaining standardized resource status transition data.

[0052] Step B-4: Based on the boundary preservation mechanism, perform causal conflict detection on the resource state transition data to obtain a set of causal conflict events.

[0053] It should be noted that the boundary preservation mechanism is used to detect causal conflicts in resource state transition events. Specifically, it verifies whether the causal relationship of each event in the resource state transition data conforms to the preset constraints through the causal boundary constraints of the causal separation architecture. The causal conflict refers to the occurrence order of events violating the causal logic of resource allocation, such as executing resources before they are allocated or using resources after they have been released. The causal boundary constraints are specifically expressed as follows: Rs resources must be allocated before execution and released after execution, while Rv resources must be allocated before use and cannot be executed again after release.

[0054] Specifically, the standardized resource state transition data is traversed through the boundary preservation mechanism to extract the causal dependencies of each event and compare them with the causal boundary constraints preset by the causal separation architecture. If the causal relationship of an event exceeds the constraint range, it is determined to be a causal conflict event. All causal conflict events are aggregated to form a causal conflict event set.

[0055] In some possible embodiments, the resource state transition data of the boiler combustion control system is detected by a boundary preservation mechanism. When traversing the data, if it is found that a certain burner start-stop control command execution resource Rs has a record of execution events preceding allocation events, which violates the causal boundary constraint, it is determined to be a causal conflict event. At the same time, if it is found that a certain combustion status monitoring data analysis resource Rv has a record of execution events after release events, it is also determined to be a causal conflict event. The two events are summarized to obtain the set of causal conflict events.

[0056] Step B-5: Update the causal boundary of the causal separation architecture based on the set of causal conflict events.

[0057] Specifically, as the system operating environment changes, such as fluctuations in node load and changes in network latency, the initial boundaries may fail to adapt to actual operational needs, leading to causal conflict events. By analyzing the set of causal conflict events, the causes of the conflicts are identified, such as overly loose boundary constraints or failure to cover special operating scenarios. The causal boundaries of the causal separation architecture are then dynamically adjusted and updated. This includes further tightening the causal constraint boundaries for strong causal resources and strengthening time sequence control; optimizing the boundary constraint range for weak causal resources to improve resource scheduling flexibility; and adjusting the causal strength coefficient α for mixed resources based on the conflict situation and optimizing the layered adaptation logic to ensure that the updated causal separation architecture can effectively avoid causal conflicts and guarantee the causal consistency of resource allocation.

[0058] In some possible embodiments, an analysis of the causal conflict event set of the boiler combustion control system reveals that the conflict of burner start-stop control Rs resource execution preceding allocation events is due to the overly loose allocation-execution time interval constraint in the initial causal boundary, which is preset to 1ms but needs to be shortened to 0.5ms in actual operation due to increased node load. The conflict of combustion status monitoring Rv resource release execution events is due to the initial boundary not covering the scenario where a new request is received after a 0.2ms delay after resource release. Based on this, the causal boundary of the causal separation architecture is updated, including adjusting the Rs resource allocation-execution time interval constraint to 0.5ms and supplementing the Rv resource causal boundary with a constraint of a 0.2ms delay after resource release before receiving a new request. Since the conflict events are unrelated to mixed resources, the causal strength coefficient of mixed resource Rm can be kept unchanged at 0.7.

[0059] Step B-6: Construct a hierarchical consensus topology based on the physical location and logical association attributes of each computing node.

[0060] Specifically, the physical location of each computing node is obtained, such as nodes in the same control room or the same equipment area being physically adjacent nodes. Logical association attributes of the nodes are also obtained, such as nodes undertaking the same functional module or having data interaction dependencies being logically associated nodes. A hierarchical consensus topology is constructed based on the physical location and logical association attributes. This hierarchical consensus topology consists of three layers: the first layer, the physical proximity layer, composed of nodes with similar physical locations, employs a strong consistency consensus mechanism to ensure high-precision synchronization of time-series information between nodes; the second layer, the logical association layer, composed of logically closely related nodes, employs a medium consistency consensus mechanism to balance synchronization accuracy and resource overhead; and the third layer, the global coordination layer, composed of the core nodes of each functional module, employs a weak consistency consensus mechanism to achieve coordination and unification of global time-series information.

[0061] It should be noted that the strong consistency consensus mechanism means that all nodes have completely consistent understanding of timing information at the same time. Specifically, this is manifested in the verification of high-frequency interactions between nodes and strict clock calibration between master and slave nodes, thereby ensuring the timing consistency of core control nodes. The medium consistency consensus mechanism means that the timing information between nodes remains consistent within a preset deviation threshold. This is achieved through a combination of periodic synchronization and dynamic deviation calibration, which satisfies the timing requirements of node collaboration within functional modules while avoiding resource waste caused by high-frequency synchronization, and adapts to the collaboration requirements of the logical association layer. The weak consistency consensus mechanism means that the timing information between nodes does not need to be unified in real time, but only needs to achieve logical consistency during global coordination. This is achieved through periodic global aggregation calibration, allowing short-term timing deviations in local nodes, thereby reducing the resource consumption of cross-module synchronization.

[0062] In some possible embodiments, taking the physical location and logical association attributes of each node in the boiler combustion control system as an example, it is known that the furnace temperature control node and the furnace pressure control node are both located locally in the boiler control room, with a physical distance of less than 10 meters. Therefore, these two nodes can be divided into a physical proximity layer, adopting a strong consistency consensus mechanism, requiring a time deviation of less than 1ms. All burner-related field control nodes and burner group coordination nodes are combustion control function modules. Therefore, these nodes can be divided into a logical association layer, adopting a medium consistency consensus mechanism, requiring a time deviation of less than 10ms. The burner group coordination node, the boiler combustion global optimization node, and the unit load control node are all global combustion optimization functions. Therefore, they can be divided into a global coordination layer, adopting a weak consistency consensus mechanism, requiring a time deviation of less than 100ms.

[0063] Step B-7: Collect event interaction data between computing nodes and combine it with the asynchronous alignment graph to construct a probabilistic temporal consensus protocol.

[0064] Specifically, the system's interactive data acquisition module collects event interaction data between nodes in real time. This event interaction data represents the interaction records generated by each computing node during resource allocation, data transmission, and instruction execution, including information such as the type of interaction event, timestamp, and participating nodes. The distributed consensus protocol, constructed using this event interaction data and the asynchronous alignment graph, employs a high-probability strict synchronization strategy for the physical proximity layer; a strategy combining medium-probability synchronization and flexible adjustment for the logical association layer; and a strategy combining low-probability global synchronization and local autonomous adjustment for the global coordination layer, ensuring that the protocol can adapt to the consistency requirements of different layers.

[0065] It should be noted that when collecting event interaction data between computing nodes, it is necessary to collect the associated nodes in the asynchronous alignment graph. That is, only the interaction data between nodes with edge connections is collected. Non-associated nodes have no time alignment requirements and do not need to be collected. At the same time, a layered adaptation strategy is adopted to precisely match the synchronization requirements of the layered consensus topology. The interaction frequency between nodes in the physical proximity layer is high and the time accuracy requirements are strict, so the collection frequency is set to the highest, such as 1ms / time. The logical association layer takes into account the synchronization accuracy and resource overhead, so the collection frequency is set to a medium level, such as 10ms / time. The global coordination layer has lower real-time requirements, so the collection frequency is set to the lowest level, such as 100ms / time.

[0066] In some possible embodiments, event interaction data of each node in the boiler combustion control system is collected, such as command interaction data between the burner start / stop control node and the burner group coordination node, and status reporting data between the burner group coordination node and the global coordination node. Combining the edge connection relationships and weights between nodes in the asynchronous alignment graph, a probabilistic temporal consensus protocol is constructed. This protocol specifies that for the physical proximity layer, timestamp synchronization is achieved with a 99.9% probability and a synchronization deviation of no more than 1ms; for the logical association layer, timestamp synchronization is achieved with a 99% probability and a synchronization deviation of no more than 10ms; and for the global coordination layer, global timestamp coordination is achieved with a 95% probability and a coordination deviation of no more than 100ms (this is just an example of probability; the specific probability needs to be determined based on the actual situation).

[0067] Step B-8: Based on the probabilistic temporal consensus protocol, perform consensus evolution among nodes in the hierarchical consensus topology and output alignment time information.

[0068] Specifically, the consensus evolution refers to the process by which each node gradually achieves unified timing information through a timing consensus protocol, combining intra-layer interaction and inter-layer collaboration. Specifically, in a layered consensus topology, starting from the physical proximity layer, each node performs intra-layer timing synchronization based on the protocol. After achieving strong consistency, the timing information is uploaded to the logical association layer through the inter-layer consensus interface. Logical association layer nodes combine their own timing information with the information uploaded from the physical proximity layer, and perform intra-layer consensus evolution based on the protocol. After achieving medium consistency, the information is then uploaded to the global coordination layer. Global coordination layer nodes perform global timing coordination based on the information uploaded from each logical association layer, achieving weak consistency, and ultimately achieving unified timing information across the entire system.

[0069] It should be noted that strong consistency means that all nodes have completely identical understanding of the timing information at the same time, without any deviation. The criterion is that the timestamp deviation between nodes is less than a preset high-precision threshold, such as 1ms in the physical proximity layer. Medium consistency means that the timing information between nodes is consistent within a preset reasonable deviation range, allowing for small and short-term deviations. The criterion is that the timestamp deviation between nodes is less than a medium-precision threshold, such as 10ms in the logical association layer, and the duration of the deviation does not exceed a single synchronization cycle. Weak consistency means that the timing information between nodes does not need to be unified in real time, but only needs to achieve logical consistency within the global coordination cycle, allowing for short-term deviations in local nodes. The criterion is that the timestamp deviation between nodes is less than a low-precision threshold during global coordination, such as 100ms in the global coordination layer.

[0070] In some possible embodiments, the furnace temperature control node and pressure control node in the physical neighboring layer first synchronize within the layer. After achieving strong consistency by adjusting the timestamp through high-frequency interaction, the synchronized timing information is uploaded to the logical association layer. The burner group coordination node in the logical association layer combines its own timing information with the information uploaded by each physical neighboring layer to perform intra-layer consensus evolution. After adjustment, the time deviation of each node is controlled within 5ms, and then the information is uploaded to the global coordination layer. The combustion global optimization node in the global coordination layer performs global coordination on the information uploaded by each logical association layer, and finally determines the unified time base T0 of the system. At the same time, it outputs the time deviation calibration value of each node, such as the calibration value of the burner start-stop control node being -0.2ms and the calibration value of the global coordination node being +0.1ms, forming aligned time information and sending it to each node.

[0071] Step C: Construct a state machine algebra for resource allocation based on resource allocation requirements and resource classification results, and obtain resource allocation strategies. Use a remapping strategy based on drift jitter data and resource allocation strategies to obtain remapping allocation data.

[0072] Step C includes:

[0073] Step C-1: Obtain the resource allocation requirements of the thermal power plant.

[0074] It should be noted that the resource allocation requirements of thermal power plants include the priority, real-time requirements, and reliability requirements of resource allocation; these are specifically obtained by surveying the operation and management needs, equipment control requirements, and environmental emission standards of thermal power plants, combined with the resource characteristics of distributed systems.

[0075] For example, the resource allocation requirements of the boiler combustion control system are obtained, including priority requirements: strong causal resources Rs have higher priority than mixed resources Rm, and mixed resources have higher priority than weak causal resources Rv; real-time requirements: the allocation response time of Rs resources is less than or equal to 1ms, the allocation response time of Rm resources is less than or equal to 5ms, and the allocation response time of Rv resources is less than or equal to 50ms; and reliability requirements: the allocation success rate of Rs resources is greater than or equal to 99.9% in fault scenarios and the allocation success rate of all resources is greater than or equal to 99.5% in normal scenarios.

[0076] Step C-2: Based on resource allocation requirements and resource classification results, obtain the resource allocation mode state set, task request set, transition probability distribution, initial state, and acceptance state set, and construct the state machine algebra for resource allocation.

[0077] Specifically, the system extracts all possible resource allocation modes based on resource allocation requirements and resource classification results. Each mode corresponds to a specific resource scheduling logic, such as regular allocation mode, emergency allocation mode, and priority promotion mode, thereby obtaining the resource allocation mode state set Q. The system extracts the task request set Σ based on the real-time task types of the thermal power plant, such as regular control task requests, fault emergency task requests, and load adjustment task requests. The transition probability distribution δ represents the probability mapping relationship between the current allocation mode and the task request to the next allocation mode, specifically quantified through the adaptation logic of different scenarios in the resource allocation requirements. The initial state q0 is the default resource allocation mode after system startup, usually the regular allocation mode. The accepting state set F is the set of allocation modes that can remain in the system for a long time during stable operation; the emergency mode is a temporary mode and is not included in the accepting states. By integrating the resource allocation mode state set, task request set, transition probability distribution, initial state, and accepting state set, the state machine algebra is obtained, specifically represented as M=(Q,Σ,δ,q0,F).

[0078] It should be noted that the process of obtaining the transition probability distribution specifically includes defining scene adaptation priorities, including mandatory adaptation, priority adaptation, optional adaptation, and prohibited adaptation. Mandatory adaptation means that the current mode must switch to a specific target mode. Priority adaptation means that the current mode will preferentially switch to the core target mode, and can switch to the compatibility mode in extremely special scenarios. The coverage rate of the core target mode adaptation scenarios is greater than or equal to 95%, and the coverage rate of the compatibility mode adaptation scenarios is less than or equal to 5%. Optional adaptation means that the current mode can switch to multiple target modes, and the coverage rate of each mode's adaptation scenarios is... "Similar" specifically means a coverage difference of less than 10%, and "prohibited adaptation" means that the current mode absolutely cannot switch to a certain target mode. Then, constraints are set and weighted. These constraints include security risk level, real-time requirements, resource redundancy requirements, and scheduling efficiency requirements. Security risk level is the most important constraint, with a fixed weight of 0.45. Real-time requirements are next most important and are divided into strong causal resource scenarios and weak causal resource scenarios, with weights set to 0.35 and 0.25 respectively. Resource redundancy requirements are less important, corresponding to 0 in strong causal resource scenarios and 0 in weak causal resource scenarios. The scheduling efficiency requirements are lowest at 15 and 0.2, corresponding to 0.05 and 0.1 in strong-causal resource scenarios and weak-causal resource scenarios, respectively. Then, the adaptability of the target mode is quantified, defining adaptability measurement standards: 1 for complete adaptability (all constraints satisfied, no risk); 0.8 for basic adaptability (core constraints satisfied, minor constraints slightly unsatisfied, no security risk); 0.2 for insufficient adaptability (core constraints mostly satisfied, local efficiency loss present, no security risk); and 0 for complete misfitability (core constraints unsatisfied, security risk or task failure risk). Finally, the Σ (weight of a certain constraint) is used to quantify the adaptability. The overall fit score is obtained by (× the target mode fit under this constraint); finally, the fit score is mapped to a transition probability, which includes score correction rules: mandatory fit scenario → core target mode score is 1.0 after correction; priority fit scenario → core target mode score is corrected by 0.2, and the score of compatible target mode remains unchanged; optional fit scenario → the scores of each target mode remain unchanged; prohibited fit scenario → target mode score is 0; finally, the target mode transition probability is obtained through the probability mapping formula, which is expressed as target mode transition probability = score after correction of this mode / sum of scores after correction of all optional target modes.

[0079] In priority adaptation scenarios, if the score of the core target mode is too high after correction, causing the probability of the compatible mode to exceed the requirement that the proportion of extreme scenarios is less than or equal to 5%, an extreme scenario compression coefficient needs to be introduced. The extreme scenario compression coefficient is obtained through statistical analysis of historical operating data. For example, if the probability of Rs resource exhaustion when the load increases is 5%, then the compression coefficient is 0.05 ÷ theoretical compatible mode probability. The compatible mode score is compressed to ensure that the final probability conforms to the scenario adaptation logic. For example, if the theoretical probability of the compatible mode in a certain scenario is 0.1, the compression coefficient is 0.05 / 0.1 = 0.5, and the corrected compatible mode score is the original score × 0.5.

[0080] In some possible embodiments, the resource allocation mode state set Q = {normal allocation mode, Rs priority mode, emergency allocation mode} is obtained through the resource allocation requirements and classification results of the boiler combustion control system; the task request set Σ = {normal task request, load increase request, load decrease request, burner fault request, fault recovery request}; the transition probability distribution δ includes a probability of 0.95 for normal mode combined with load increase request → Rs priority mode, a probability of 1.0 for normal mode combined with fault request → emergency mode, a probability of 1.0 for emergency mode combined with fault recovery request → normal mode, etc.; the initial state q0 is normal allocation mode; the accepting state set F = {normal allocation mode, Rs priority mode}; and finally, the state machine algebra M is constructed through the above sets.

[0081] Step C-3: Define the operation rules of the state algebra and generate a resource allocation strategy based on the state machine algebra.

[0082] Specifically, the operational rules of the state algebra are defined, including the disjunction operation ∨, which represents nondeterministic selection and adapts to the selectability of modes in different scenarios; the conjunction operation ∧, which represents concurrent execution of modes and adapts to multi-task collaborative scenarios; and the difference operation \, which represents the behavior of excluding a certain mode and adapts to special constraint scenarios. The allocation modes in the state machine algebra are combined and optimized through the operational rules to form a directly executable resource scheduling scheme, i.e., a resource allocation strategy.

[0083] It should be noted that the combination and optimization process includes: extracting the resource allocation mode state set as the basic module, extracting the task request set and transition probability distribution as the configuration basis; combining the modes in Q into executable logic according to actual operating requirements, i.e., the core logic of the strategy; and then integrating all the logic to form a complete resource allocation strategy.

[0084] For example, the disjunction operation ∨ indicates optional scenarios, such as a regular scenario where the regular mode or the Rs priority mode can be selected; the conjunction operation ∧ indicates concurrent modes, such as the regular allocation mode and the resource monitoring mode being executed concurrently; and the difference operation \ indicates exclusion behavior, such as the emergency mode excluding non-core processes in the regular mode. A resource allocation strategy is generated based on the operation rules and state machine algebra. The resource allocation strategy includes a strategy algebraic expression and strategy core logic. The strategy algebraic expression is Pol=(Bas∧Mon)∨(Em\Nor), where Bas is the regular allocation mode, suitable for regular tasks; Mon is the resource monitoring mode, monitoring resource status in real time; Em is the emergency allocation mode, suitable for fault scenarios; and Nor is the regular allocation process. The strategy core logic means that in regular scenarios, the regular allocation mode and the resource monitoring mode are executed concurrently; in fault scenarios, the emergency allocation mode is executed, excluding non-core steps in the regular process and prioritizing Rs resource allocation.

[0085] Step C-4: Obtain clock drift data and network latency jitter data for each computing node and combine them into drift jitter data.

[0086] For example, clock drift data of each node in the boiler combustion control system can be collected through the clock calibration module, including +0.2ms / second drift data for the burner start / stop control node, -0.1ms / second drift data for the furnace temperature control node, and +0.05ms / second drift data for the global coordination node; network latency jitter data can be collected through the network performance monitoring module, including latency jitter range of 0.3-0.8ms between the burner start / stop control node and the burner group coordination node, and latency jitter range of 1.2-2.5ms between the burner group coordination node and the global coordination node; the above data can be integrated to form a drift jitter data set {clock drift [+0.2, -0.1, +0.05, ...], network latency jitter [0.3-0.8, 1.2-2.5, ...]}.

[0087] Step C-5: Obtain the original resource allocation data based on the resource allocation strategy, and combine it with the drift jitter data to perform time warping to obtain the original resource allocation sequence.

[0088] Specifically, raw resource allocation data is generated based on resource allocation strategies and the real-time task requirements of thermal power plants. This raw resource allocation data includes the timestamp of resource allocation and the resource allocation value, represented as Z={(t...} k ,r k )}, where Z represents the original resource allocation data, and t k Represented as a timestamp for resource allocation, the r kThis is represented as a resource allocation value. Due to the drift deviation of the local clock, the timestamp of the original data has timing errors. It is necessary to perform time warping operations by combining the drift jitter data. Specifically, through the timing alignment operator, the local timestamp of the original data is mapped to a unified time base. During the mapping process, the deviation range in the drift jitter data is used as a constraint, while maintaining the causal order of events.

[0089] It should be noted that the steps for obtaining the original resource allocation data specifically include: extracting core requirement elements from the real-time task requirements of the thermal power plant, including task type (e.g., burner start-up and shutdown control, combustion status monitoring), execution nodes (e.g., burner start-up and shutdown control nodes, global coordination nodes), and resource requirement details (e.g., resource type, resource quantity, resource priority), and task time requirements (e.g., task start time limit, estimated execution time). These are used for subsequent initial timestamp matching and standardized processing to form a structured requirement in a unified format. Based on the standardized real-time task requirements, matching the corresponding allocation rules from the resource allocation strategy and extracting core rule elements as constraints for generating allocation data. The real-time core rule elements include: matching priority rules according to task type and resource type (e.g., if the priority of Rs resource is higher than Rm and Rv in the strategy, and the task requirement is Rs resource, then the highest priority allocation rule is extracted); and matching adaptation mode rules according to task scenario (e.g., if the task requirement is burner start-up and shutdown under a load increase scenario, then the allocation rule corresponding to the Rs priority mode in the strategy is matched). The process involves matching quantity constraint rules based on execution nodes and resource types. For example, if a single burner start / stop control node is allocated a maximum of 2 Rs resources according to the strategy, then this upper limit constraint is extracted. Finally, standardized task requirements and strategy rules are collaboratively matched to obtain raw resource allocation data. First, the resource allocation value is determined. Combining the resource type / quantity of the task requirements with the quantity constraints / priority of the strategy rules, the final allocated resource type and quantity are determined. If the resource quantity required by the task does not exceed the upper limit of the strategy rules, the task requirement quantity is directly adopted. If it exceeds the upper limit, the upper limit of the strategy rules is used for allocation. If the task requirement does not specify a quantity, the default adaptive quantity of the strategy rules is used for allocation, such as the default allocation of 2 Rv resources for regular combustion status monitoring tasks. Then, the initial timestamp is determined. Based on the task start time limit after parsing the task requirements, and combined with the local clock of the execution node, an initial allocation timestamp is generated, which is the planned start time for resource allocation. If the task does not specify a start time limit, the real-time task allocation requirement of the strategy rules is followed, and the local clock time of the current execution node is used as the initial timestamp.

[0090] In some possible embodiments, based on the resource allocation strategy and real-time task requirements of the boiler combustion control system, such as burner start-up and shutdown tasks under normal load, raw resource allocation data Z={(T1,Rs-1),(T2,Rm-2),(T3,Rv-1)} is generated, where T1, T2, and T3 are timestamps generated by the local clock of each node, Rs-1 represents one strongly causal resource, Rm-2 represents two mixed resources, and Rv-1 represents one weakly causal resource; this is combined with drift jitter data... The line time warp maps T1 (local drift + 0.2ms) to T1' = T1 - 0.2ms, T2 (local drift - 0.1ms) to T2' = T2 + 0.1ms, and T3 (local drift + 0.05ms) to T3' = T3 - 0.05ms, maintaining the causal order of T1' before T2' before T3', ultimately yielding the original resource allocation sequence A' = {(T1', Rs - 1), (T2', Rm - 2), (T3', Rv - 1)}.

[0091] Step C-6: Remap the original resource allocation sequence to obtain the remapped allocation data.

[0092] Specifically, the resource flow integral conservation condition is defined based on the system conservation principle, meaning that the cumulative resource allocation remains unchanged before and after the mapping between the original and target times. First, the original resource allocation sequence A' is obtained through step C-5, and the target time sequence A'' is obtained through the alignment time information in step B, establishing the correspondence between the original and target time sequences. Simultaneously, the causal relationship derivation in step A-2 and the resource classification results in step B-2 are used to obtain the sequential logic of resource allocation. The total cumulative resource amount up to each time point in the original time sequence is then calculated. Simultaneously, sampling is performed on the target time sequence to verify that the total cumulative resource amount in the target time sequence is consistent with the original sequence. Then, the specific resource allocation value at each target time point is deduced from the total cumulative amount. Finally, the sequential logic of resource allocation is verified to obtain the remapping allocation data.

[0093] It should be noted that a unified time base is obtained from the alignment time information. Based on the unified time base and the timing requirements of resource allocation, such as task execution cycle and resource scheduling frequency, the sampling interval and range of the target time point are determined to generate the target time series. In the embodiment of the distributed system of thermal power plant, the priority logic of resource allocation is that strong causal resource Rs is allocated before mixed resource Rm, and mixed resource Rm is allocated before weak causal resource Rv.

[0094] In some possible embodiments, assume that the original resource allocation sequence A'={(T1',Rs-1),(T2',Rm-2),(T3',Rv-1)} is obtained, where T1'=100.1ms, T2'=103.2ms, and T3'=106.1ms. The target time series A''={T1''=100.0ms, T2''=103.0ms, T3''=106.0ms} is obtained. First, establish the correspondence between A' and A'', which can be done using a one-to-one mapping rule, such as T1'→T1'', T2'→T2'', T3'→T3'', to eliminate deviations in the original resource allocation sequence while ensuring that the time order is not reversed. Up to T1', only Rs-1 has been allocated, with a total cumulative amount of 1. Up to T2', Rs-1 has been allocated... The total cumulative amount is 3, and Rs-1, Rm-2, and Rv-1 are allocated up to T3', with a total cumulative amount of 4. Then, the target time series is sampled for verification. It is found that the cumulative amount of sampling at T1'' is 1, the cumulative amount of sampling at T2'' is 3, and the cumulative amount of sampling at T3'' is 4, which is consistent with the original sequence and passes the conservation verification. Then, the specific resource allocation values ​​at each target time point are deduced by using the cumulative amount of 0 at T0''=0ms. Rs-1 is allocated at T1'', Rm-2 is allocated at T2'', and Rv-1 is allocated at T3''. Finally, the sequential logic of resource allocation is verified and it is found that the load sequence constraint is not found and there is no causal conflict. The remapping allocation data A''={(T1'',Rs-1),(T2'',Rm-2),(T3'',Rv-1)} is output.

[0095] Step D: Obtain node state data based on the asynchronous alignment graph and correct the node state data by combining it with the remapping allocation data, and obtain the corrected node state data.

[0096] Step D includes:

[0097] Step D-1: Obtain the neighbor nodes of each computing node based on the asynchronous alignment graph.

[0098] For example, through the asynchronous alignment diagram of the boiler combustion control system, it is found that the associated edge of the burner 1 start-stop control node connects the burner group coordination node and the furnace temperature control node, so its neighboring nodes are the burner group coordination node and the furnace temperature control node; the associated edge of the burner group coordination node connects all burner start-stop control nodes and the global coordination node, so its neighboring nodes are the 6 burner start-stop control nodes and the global coordination node; the associated edge of the global coordination node connects the burner group coordination node and the unit load control node, so its neighboring nodes are the burner group coordination node and the unit load control node.

[0099] Step D-2: Collect local status data and neighbor node status data for each computing node.

[0100] Specifically, the local status monitoring module of each node collects and caches the local status data of each computing node in real time, requests the data from neighboring nodes through a distributed communication protocol, and caches it locally, thereby obtaining the status data of neighboring nodes.

[0101] In some possible embodiments, in the boiler combustion control system, the burner 1 start-stop control node collects local status data, including resource occupancy status of 1 unit of Rs resource, task execution progress of 80% completion of burner start-stop task, local clock status of calibrated according to alignment time information, and hardware operation status of normal. At the same time, it requests status data from neighboring nodes, the burner group coordination node and the furnace temperature control node, through a distributed communication protocol. This data includes the burner group coordination node's status data of 2 units of Rm resource occupied, task execution progress of 60% completion of coordination task, and the furnace temperature control node's status data of 1 unit of Rs resource occupied, furnace temperature of 1280°C, and task execution progress of 90% completion of temperature control task.

[0102] Step D-3: Perform state detection on the local state data and neighbor node state data based on the predicate. If there is a state inconsistency problem, correct it by remapping and allocating data, and output the corrected node state data. If there is no state inconsistency problem, directly output the local state data as the corrected node state data.

[0103] It should be noted that the predicate is a logical proposition used to determine the consistency of node state data. Its definition is based on system-preset state consistency constraints, such as resource usage matching, task execution progress coordination, and timestamp synchronization. Specifically, it means that all events of node i at time t are consistent with the local state data and the neighbor state data. The state detection process involves traversing the collected local and neighbor node state data and verifying whether the predicate is true. If the predicate is true, it means that the node state is consistent and no correction is needed. If the predicate is false, it means that there is a state inconsistency problem, such as mismatch in resource usage or asynchronous task progress.

[0104] Understandably, in a distributed system of a thermal power plant, the defined state consistency constraints include: resource occupancy matching, specifically expressed as the coordinating node's resource amount Rm × 3 = the total resource amount Rs of all subordinate burner nodes, where 1 unit of Rm corresponds to 3 units of Rs; task progress coordination, specifically expressed as the burner start-up and shutdown task progress being greater than or equal to the coordinating node's task progress, thereby avoiding coordination lag; and timestamp synchronization, specifically expressed as the timetamp deviation between the local node and its neighboring nodes being less than or equal to 0.5ms. The predicate is valid only if all criteria are met; if any one criterion is not met, the predicate is invalid.

[0105] In some possible embodiments, the state data of the burner 1 start-stop control node is detected by predicates. The detection reveals that the burner group coordination node occupies 2 copies of Rm resources, and according to the predicate, 6 copies of Rs resources should be allocated accordingly. However, the 6 burner start-stop control nodes actually occupy 5 copies of Rs resources, resulting in a 1-copy shortfall and a state inconsistency issue. The start-stop task progress is 80%, and the coordination task progress is 60%, indicating a coordinated task progress. The local timestamp is T1, and the neighbor node's timestamp is T2, with the difference between them being less than or equal to 0.5ms. Interstitial synchronization; based on the discovery of predicate inconsistencies, and using the remapping allocation data A'' as a basis, A'' clearly states that 2 copies of Rm resources correspond to 6 copies of Rs resources. A correction instruction is generated to allocate 1 copy of Rs resources to the burner 6 start-stop control node, which has not occupied Rs resources. After the correction is completed, the predicate is checked again to confirm its validity, and the corrected node status data is output. The start-stop control nodes of burners 1-5 each occupy 1 copy of Rs resources, the start-stop control node of burner 6 is newly allocated 1 copy of Rs resources, the burner group coordination node occupies 2 copies of Rm resources, and the task progress of each node is synchronized.

[0106] Step E: Based on the alignment time information, resource allocation strategy, and corrected node status data, obtain the resource allocation result.

[0107] Step E includes:

[0108] Step E-1: Receive resource request data from resource-related event data.

[0109] Specifically, the receiving process is implemented through the system's node communication interface. The communication interface is adapted to the communication protocol of the distributed system to ensure the real-time performance and reliability of data transmission. The resource request data is real-time data from each node in the thermal power plant's distributed system requesting resources from the system to complete specific tasks. The received resource request data needs to undergo preliminary format verification and legality verification to filter invalid requests, such as those for non-existent resource types or requests exceeding the system's capacity, and retain valid resource request data. Valid resource request data includes key information such as the requesting node, resource type, request quantity, priority, and request timestamp.

[0110] In some possible embodiments, the boiler combustion control system receives resource request data through a node communication interface. The request data sent by a burner 2 start-stop control node includes: the requesting node is the burner 2 start-stop control node, the resource type is Rs burner start-stop control resource, the request quantity is 1 copy, the priority is the highest priority, and the request timestamp is Tr. The request timestamp is generated by the local clock. At the same time, the system performs format verification and legality verification on the request. The Rs resource exists, and the request quantity of 1 copy does not exceed the system's carrying capacity. Therefore, it is determined to be a valid request, and the resource request data is retained.

[0111] Step E-2: Calibrate the timestamps of resource request data based on alignment time information.

[0112] Specifically, the timestamp of the resource request data is generated by the local clock of the requesting node. Due to clock drift deviations among nodes, this timestamp is inconsistent with the unified time base of the system. If it is used directly for resource allocation, it may lead to chaotic allocation timing, such as requests sent earlier being allocated later. Therefore, it is necessary to calibrate the request timestamp by aligning time information. The alignment time information includes the time deviation calibration value between the unified time base of the system and the time of each node. By adding or subtracting the corresponding calibration value from the local timestamp of the requesting node, the timestamp is mapped to the unified time base of the system to generate the calibrated timestamp.

[0113] In some possible embodiments, in the boiler combustion control system, the resource request timestamp of the burner 2 start-stop control node is Tr, and the time deviation calibration value of this node in the alignment time information is -0.2ms; Tr is calibrated by the alignment time information, and the calibrated timestamp Tr' = Tr - 0.2ms is mapped to the unified time base of the system; at the same time, the request timestamp Tr1 of the burner 1 start-stop control node is received, and the calibration value is +0.1ms, and after calibration, Tr1' = Tr1 + 0.1ms.

[0114] Step E-3: Based on the calibrated resource request data, and in conjunction with the resource allocation strategy and corrected node status data, resource allocation is performed to obtain the resource allocation result.

[0115] Specifically, the resource allocation process is triggered by the calibrated resource request data. Combining the resource allocation strategy generated in step C-3 and the corrected node status data output in step D-3, the allocation calculation is performed using a dynamic priority algorithm based on causal consistency. The allocation calculation process must follow three core principles: the priority principle, which allocates resources according to the resource priority set in the resource allocation strategy, such as Rs having a higher priority than Rm, which in turn has a higher priority than Rv; the causal preservation principle, which ensures that the timing of resource allocation conforms to the causal logic of request-allocation; and the state adaptation principle, which, in conjunction with the corrected node status data, ensures that the allocated resources do not exceed the system's remaining resource capacity and are coordinated with the task progress of each node. After the allocation is completed, a resource allocation result is generated, which includes information such as the allocated node, the type of allocated resource, the quantity allocated, the allocation timestamp, and the allocation status.

[0116] It should be noted that the specific process of performing the allocation calculation includes: first, initializing the scheduling queue; creating three levels of dedicated scheduling queues according to the priority hierarchy in the resource allocation strategy, including high, medium, and low priorities; and simultaneously initializing a causal dependency cache pool to cache the causal relationships of historical resource allocation events, such as request-allocation time sequence pairs corresponding to allocated Rs resources; the algorithm maps requests to corresponding priority queues based on the type of resource request and the real-time scenario, such as Rs resource requests for burner start / stop control → high-priority queue, Rm resource requests for burner parameter optimization → medium-priority queue, and Rv resource requests for combustion status monitoring → low-priority queue; extracting the causal dependencies of the requests to be allocated; for the currently scheduled requests, the algorithm's built-in causal dependency detection module queries the causal dependency cache pool to determine the causal constraints that they must satisfy, such as verifying whether a new Rs resource request has a preceding resource allocation event, such as the burner group... The algorithm grants permission to allocate Rm resources to the coordinating node, provided that the preceding event precedes the current request. If there is no conflict, proceed to the next step; if a conflict exists, the request is postponed until the preceding causal time is completed before being enqueued. It reads the status data of the correction node to determine if the remaining system resources meet the current request, including resource quantity verification. For example, if the system has 3 remaining Rs resources and requests 1, the condition is met. If there is 1 remaining but 2 are requested, it is considered insufficient resources and marked as allocation failure. Task progress is also verified. For example, if the burner 2's start / stop task is 80% complete and Rs resources are needed to finish, the algorithm determines that the resource allocation matches the task progress and allows allocation. If all verifications pass, the allocation parameters are calculated, including the specific identifier of the allocated resource, such as Rs-003, the target allocation node, and the allocation timestamp. Finally, the algorithm outputs the resource allocation result, including the allocation node, resource type, allocation quantity, allocation timestamp, and allocation status.

[0117] In some possible embodiments, the resource request data (Tr', 1 copy of Rs resource, highest priority) of the burner 2 start-stop control node is combined with the resource allocation strategy (Rs resource has the highest priority, and the allocation response time is less than or equal to 1ms) and the corrected node status data (the current system has 3 copies of Rs resource remaining, and the burner 2 start-stop control node has no Rs resource occupied). The allocation calculation is performed by a dynamic priority algorithm based on causal consistency. It is determined that the system has enough remaining Rs resource and the request has the highest priority, which meets the allocation conditions. One copy of Rs resource is allocated to the burner 2 start-stop control node. The resource allocation result is generated, including the allocation node is the burner 2 start-stop control node, the allocation resource type is Rs, the allocation quantity is 1 copy, the allocation timestamp is Ta, and the allocation status is successful.

[0118] Step E-4: Dynamically allocate resources to the distributed system of the thermal power plant based on the resource allocation results.

[0119] For example, the resource scheduling module of the boiler combustion control system deploys one Rs resource to the burner 2 start-stop control node, such as the burner start-stop control resource, based on the allocation result. After the deployment is completed, the status feedback confirms that the resource deployment was successful, and the burner 2 start-stop control node can use the resource to perform burner start-stop tasks normally. At the same time, the allocation result is synchronized to its neighboring nodes, and the neighboring nodes update their local resource status cache.

[0120] Specifically, a dynamic resource allocation system for a distributed system in a thermal power plant includes:

[0121] The acquisition module is used to acquire local time-series data and resource-related event data of each computing node;

[0122] The construction module is used to construct an ordered time algebra system, construct a causal separation architecture and obtain resource classification results, construct a hierarchical consensus topology, construct a state machine algebra for resource allocation and obtain resource allocation strategies;

[0123] The processing module obtains the asynchronous alignment graph and time-series alignment operator based on the ordered time algebra system, and obtains the resource allocation result based on the alignment time information, resource allocation strategy and correction node state data;

[0124] An evolution module is used to perform consensus evolution on the consensus topology and obtain alignment time information;

[0125] The mapping module uses a remapping strategy based on drift jitter data and resource allocation strategy to obtain remapping allocation data;

[0126] The correction module obtains node state data based on the asynchronous alignment graph and corrects the node state data by combining it with remapping allocation data, thereby obtaining corrected node state data.

[0127] The specific usage and function of this embodiment are explained below:

[0128] First, local time-series data and resource-related event data of each computing node are acquired, and an ordered time algebra system is constructed. An asynchronous alignment graph and a time-series alignment operator are output. Next, a causal separation architecture updated through the time-series alignment operator is constructed, and resource classification results are obtained. A hierarchical consensus topology is simultaneously constructed, and consensus evolution is performed using the asynchronous alignment graph to obtain alignment time information. Based on resource allocation requirements and resource classification results, a state machine algebra for resource allocation is constructed, and a resource allocation strategy is obtained. A remapping strategy using drift jitter data and the resource allocation strategy is adopted to obtain remapped allocation data. Node state data is obtained based on the asynchronous alignment graph, and the node state data is corrected using the remapped allocation data to obtain corrected node state data. Finally, the resource allocation result is obtained using alignment time information, the resource allocation strategy, and the corrected node state data. This method, by constructing a causal separation architecture, classifies resources into three categories: strongly causal, weakly causal, and hybrid resources. A differentiated scheduling mechanism is adopted for different types of resources to improve the resource utilization of weak causal auxiliary analysis tasks while ensuring the real-time performance of strong causal control tasks. By collecting local and neighbor node state data, using predicates for consistency detection, and combining remapping allocation data to correct inconsistent states, the system ensures that the resource occupancy, task progress, and other state information of each node are synchronized in real time, thereby improving the reliability of resource allocation. By constructing an ordered time algebra system, asynchronous alignment graphs and time-series alignment operators are generated to eliminate time-series deviations among nodes. At the same time, through causal relationship derivation and conflict filtering mechanisms, the causal dependencies between events are clarified, solving the causal conflict problem caused by time-series disorder in existing solutions, thereby improving the accuracy of system resource allocation. This dynamic resource allocation scheme for distributed systems in thermal power plants solves the problem of poor resource allocation adaptability in existing technologies, thereby improving the accuracy of resource allocation in distributed systems of thermal power plants.

[0129] It should be understood that, in the embodiments of the present invention, the order of the above-mentioned process numbers does not imply the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of the present invention.

[0130] The above-described embodiments are only used to illustrate the technical solutions of the present invention, and are not intended to limit it. Although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of the present invention, and should all be included within the protection scope of the present invention.

Claims

1. A method for dynamic resource allocation in a distributed system of a thermal power plant, characterized in that, It includes the following steps: Acquire local time-series data and resource-related event data from each computing node and construct an ordered time algebra system, outputting an asynchronous alignment graph and a time-series alignment operator; Construct a causal separation architecture based on time-series alignment operator updates and obtain resource classification results. Simultaneously construct a hierarchical consensus topology and combine it with an asynchronous alignment graph to perform consensus evolution and obtain alignment time information. Based on resource allocation requirements and resource classification results, a state machine algebra for resource allocation is constructed and a resource allocation strategy is obtained. A remapping strategy based on drift jitter data and resource allocation strategy is adopted to obtain remapping allocation data. Node state data is obtained based on asynchronous alignment graph and corrected by combining remapping and allocation data to obtain corrected node state data; Based on alignment time information, resource allocation strategy, and correction node status data, the resource allocation result is obtained.

2. The method for dynamic resource allocation in a distributed system of a thermal power plant according to claim 1, characterized in that, Acquire local time-series data and resource-related event data from each compute node and construct an ordered time algebra system, outputting an asynchronous alignment graph and time-series alignment operators, including: Local time-series data and resource-related event data are acquired through the data acquisition modules of each computing node; Based on local time series data and resource-related event data, the local time manifold of each node is obtained, and an ordered time algebra system is constructed based on the local time manifold. Output asynchronous alignment graphs and time-series alignment operators based on ordered time algebraic systems.

3. The method for dynamic resource allocation in a distributed system of a thermal power plant according to claim 2, characterized in that, The method further includes: The computing nodes include field control nodes, module coordination nodes, and global coordination nodes within the distributed control system of a thermal power plant. The resource-related event data includes resource request data, resource release data, and resource state transition event data.

4. The method for dynamic resource allocation in a distributed system of a thermal power plant according to claim 1, characterized in that, Construct a causal separation architecture based on temporal alignment operator updates and obtain resource classification results, including: Acquire attribute data of each resource within the distributed system of a thermal power plant, wherein the attribute data includes the causal characteristics and functional types of the resources; Based on the attribute data, a causal separation architecture is built, and resources are classified to obtain resource classification results; Collect raw resource state transition data and align the raw resource state transition data using a time-series alignment operator to obtain resource state transition data; Based on the boundary preservation mechanism, causal conflict detection is performed on resource state transition data to obtain a set of causal conflict events. The causal boundary of the causal separation architecture is updated based on the set of causal conflict events.

5. The method for dynamic resource allocation in a distributed system of a thermal power plant according to claim 1, characterized in that, Construct a layered consensus topology, combine it with an asynchronous alignment graph for consensus evolution, and obtain alignment time information, including: A hierarchical consensus topology is constructed based on the physical location and logical association attributes of each computing node; Collect event interaction data between computing nodes and combine it with asynchronous alignment graphs to construct a probabilistic temporal consensus protocol; Based on a probabilistic temporal consensus protocol, the consensus evolution between nodes in the hierarchical consensus topology is performed, and alignment time information is output.

6. The method for dynamic resource allocation in a distributed system of a thermal power plant according to claim 1, characterized in that, Based on resource allocation requirements and resource classification results, a state machine algebra for resource allocation is constructed, and resource allocation strategies are obtained, including: Obtain the resource allocation needs of thermal power plants; Based on resource allocation requirements and resource classification results, obtain the resource allocation mode state set, task request set, transition probability distribution, initial state and acceptance state set, and construct the state machine algebra for resource allocation; Define the operational rules of state algebra and generate resource allocation strategies based on state machine algebra.

7. The method for dynamic resource allocation in a distributed system of a thermal power plant according to claim 1, characterized in that, A remapping allocation strategy based on drift jitter data and resource allocation tactics is used to obtain remapping allocation data, including: Obtain clock drift data and network latency jitter data from each computing node and combine them into drift jitter data; The original resource allocation data is obtained based on the resource allocation strategy, and time warping is performed by combining drift jitter data to obtain the original resource allocation sequence. Remap the original resource allocation sequence to obtain the remapped allocation data.

8. The method for dynamic resource allocation in a distributed system of a thermal power plant according to claim 1, characterized in that, The node state data is obtained based on the asynchronous alignment graph and corrected by combining it with remapping and allocation data. The corrected node state data includes: Obtain the neighbor nodes of each computing node based on the asynchronous alignment graph; Collect local status data and neighboring node status data from each computing node; State detection is performed on local state data and neighbor node state data based on predicates. If there is a state inconsistency problem, the data is remapped and allocated to correct it, and the corrected node state data is output. If there is no state inconsistency problem, the local state data is directly output as the corrected node state data.

9. A method for dynamic resource allocation in a distributed system of a thermal power plant according to claim 1, characterized in that, Based on alignment time information, resource allocation strategy, and corrected node status data, the resource allocation results are obtained, including: Receive resource request data from resource-related event data; The timestamps of resource request data are calibrated based on alignment time information; Based on the calibrated resource request data, combined with the resource allocation strategy and corrected node status data, resource allocation is performed to obtain the resource allocation result; Dynamic resource allocation is performed on the distributed system of thermal power plants based on the resource allocation results.

10. A dynamic resource allocation system for a distributed system in a thermal power plant, used to implement the method described in any one of claims 1-9, characterized in that, include: The acquisition module is used to acquire local time-series data and resource-related event data of each computing node; The construction module is used to construct an ordered time algebra system, construct a causal separation architecture and obtain resource classification results, construct a hierarchical consensus topology, construct a state machine algebra for resource allocation and obtain resource allocation strategies; The processing module obtains the asynchronous alignment graph and time-series alignment operator based on the ordered time algebra system, and obtains the resource allocation result based on the alignment time information, resource allocation strategy and correction node state data; An evolution module is used to perform consensus evolution on the consensus topology and obtain alignment time information; The mapping module uses a remapping strategy based on drift jitter data and resource allocation strategy to obtain remapping allocation data; The correction module obtains node state data based on the asynchronous alignment graph and corrects the node state data by combining it with remapping allocation data, thereby obtaining corrected node state data.

Images