Distributed display system command computation method based on delta computation

Abstract

The application discloses a kind of distributed display system command calculation methods based on incremental calculation, comprising: generating and maintaining current entity set, change entity set and last calculation entity set;When entity changes, obtain change entity from change entity set;The last calculation entity set is merged with change entity to form union set;Current incremental calculation model is constructed;Last incremental calculation model is constructed;The intersection of current incremental calculation model and last incremental calculation model is calculated;Based on the relationship link of entity, all associated entities of the entity in intersection are collected;The entity in intersection and all associated entities are merged to build the entity set to be calculated;The entity set to be calculated is input into calculator to perform incremental calculation to obtain calculation result.The application solves the problem that the full amount calculation method is used in large-scale distributed video splicing display system, which has huge calculation overhead, long response time and cannot meet real-time requirements.

Description

Technical Field

[0001] This invention relates to the field of communication technology, and more specifically to a command calculation method for a distributed display system based on incremental computation. Background Technology

[0002] Distributed video splicing display systems (such as the Chinese patent with publication number CN203151670U) are modern display and control systems based on IP networks that distribute the acquisition, transmission, processing, and display capabilities of video signals across multiple independent nodes. In large-scale distributed video splicing display systems, the system needs to manage a large number of core logical entities, including input nodes (Inodes), output nodes (Onodes), signals, composite signals, windows, and walls, and calculate the relationships and configuration parameters between them. These core logical entities have complex dependencies: windows depend on signals or composite signals, signals depend on input nodes, windows belong to walls, and walls contain output nodes, etc.

[0003] Traditional full-scale computation requires recalculating the relationships and configuration parameters of all entities each time. When the system is large (e.g., containing hundreds of input nodes, hundreds of output nodes, and thousands of windows), the computational overhead is enormous, the response time is too long, and it cannot meet real-time requirements. Existing full-scale computation methods have the following problems: Low computational efficiency: Every change requires a full calculation, which is computationally intensive and time-consuming. When the system contains a large number of entities, a full calculation may take several seconds or even longer.

[0004] Resource waste: A large number of unchanged entities are repeatedly calculated, wasting computing resources. In practical applications, in most cases only a small number of entities change, but the system still needs to calculate all entities.

[0005] Response latency: Full computation causes system response latency, impacting user experience. This latency issue is particularly pronounced in scenarios requiring real-time interaction.

[0006] Poor scalability: As the system size increases, the performance issues of full-scale computation become more prominent. When the system size grows linearly, the computation time may increase exponentially.

[0007] Lack of intelligent dependency tracking: Existing technologies cannot automatically identify dependencies between entities, requiring manual maintenance of dependencies, which is prone to errors and has high maintenance costs. Summary of the Invention

[0008] To overcome the shortcomings of existing technologies, a command calculation method for distributed display systems based on incremental computing is provided to solve the problems of huge computational overhead, excessively long response time, and inability to meet real-time requirements when using full calculation in large-scale distributed video splicing display systems.

[0009] To achieve the above objectives, a command calculation method for a distributed display system based on incremental computation is provided, comprising the following steps: The system manages the latest state of all entities in the distributed display system and generates the current entity set, records the entities that have changed and generates the changed entity set, saves the entity snapshot used in the last incremental calculation and generates the last calculation entity set, and simultaneously maintains the current entity set, the changed entity set, and the last calculation entity set; When an entity changes, the changed entity is recorded in the changed entity collection; The changed entity is obtained from the changed entity set, and the old entity corresponding to the changed entity is obtained from the previously calculated entity set; The previously calculated entity set is merged with the changed entity and the old entity to form a union set; Extract the current entity corresponding to the entity in the union set from the current entity set to construct the current incremental calculation model; Extract the previous computation entity corresponding to the entity in the union set from the previous computation entity set to construct the previous incremental computation model; Calculate the intersection of the current incremental calculation model and the previous incremental calculation model; Based on the relationship links of entities, collect all related entities of the entities in the intersection; The entities in the intersection are merged with all the associated entities to construct the entity set to be calculated; Input the set of entities to be calculated into the calculator to perform incremental calculations to obtain the calculation results, and maintain and update the set of entities from the previous calculation. Based on the calculation results, system control commands are generated. Furthermore, when collecting all associated entities of the entities in the intersection, entities are processed in batches using a queue mechanism with a breadth-first search algorithm.

[0010] Furthermore, the intersection of the current incremental calculation model and the previous incremental calculation model is calculated using a difference calculation algorithm.

[0011] Furthermore, when merging the entities in the intersection with all associated entities to construct the entity set to be calculated, the aging values ​​of the input and output nodes in all entities are traversed. Each time incremental calculation is triggered, the aging values ​​of all input and output nodes decrease. A node is marked as an aging node when the aging value of the input node or the output node is lower than a preset threshold. The aging nodes are incorporated into the set of entities to be computed.

[0012] The beneficial effects of the present invention are that the distributed display system command calculation method based on incremental calculation of the present invention maintains the current entity set, the changed entity set and the last calculated entity set, and adopts intersection identification and dependency collection, and only performs incremental calculation on the changed entities and their related entities, avoiding the repeated processing of all entities in the full calculation, greatly improving the calculation efficiency and reducing the calculation overhead.

[0013] The incremental computing-based command calculation method for distributed display systems of the present invention eliminates invalid calculations on unchanged entities such as input nodes, output nodes, signals, and walls, significantly reducing CPU and memory usage, saving system resources, and improving resource utilization. Detailed Implementation

[0014] The present application will now be described in further detail with reference to the embodiments. It is to be understood that the specific embodiments described herein are merely illustrative of the invention and not intended to limit the invention.

[0015] It should be noted that, unless otherwise specified, the embodiments and features described in this application can be combined with each other. The present application will now be described in detail with reference to the embodiments.

[0016] This invention provides a command calculation method for a distributed display system based on incremental computation, comprising the following steps: a. Manage the latest state of all entities in the distributed display system and generate the current entity set, record the entities that have changed and generate the changed entity set, save the entity snapshot used in the last incremental calculation and generate the last calculation entity set, and simultaneously maintain the current entity set, the changed entity set and the last calculation entity set.

[0017] The core logical entities of a distributed display system include input nodes, output nodes, signals, composite signals, windows, and walls.

[0018] Generate the current entity set to manage the latest state of all current entities, where: Inode Manager: Manages all input nodes; Onode Manager: Manages all output nodes; Signal Manager: Manages all signals; Comp Signal Manager: Manages all composite signals; Wall Manager: Manage all walls; Window Manager: Manages all windows.

[0019] The changed entity set is used to record entities that have undergone changes, where: Increment Inode Manager: Records the input nodes that have changed; Increment Onode Manager: Records output nodes that have undergone changes; Increment Signal Manager: Records signals that have changed. Increment Comp Signal Manager: Records composite signals that have changed; Increment Wall Manager: Records walls that have changed; Increment Window Manager: Records windows that have changed.

[0020] The previously computed entity set is used to store snapshots of the entities used in the last computation, where: Last Inode Manager: Saves a snapshot of the input node used in the last computation; last Onode Manager: Saves a snapshot of the output node used in the last computation; last Signal Manager: Saves a snapshot of the signals used in the last calculation; last Comp Signal Manager: Saves a snapshot of the composite signal used in the last calculation; Last Wall Manager: Saves the last wall snapshot used in the calculation; Last Window Manager: Saves a snapshot of the window used in the last calculation.

[0021] b. When an entity changes, the changed entity is recorded in the changed entity set.

[0022] When an entity in the distributed display system changes (creates, deletes, or modifies), the changed entity is recorded in the corresponding incremental manager, and the incremental calculation flag is triggered.

[0023] c. Obtain the changed entity from the changed entity set, and obtain the old entity corresponding to the changed entity from the previously calculated entity set.

[0024] Specifically, all changed entities are retrieved from the Increment Manager. The corresponding entities are then identified from the Last Manager using the Filter Manager (used to implement step d). The Increment Manager and Last Manager are collective terms for the aforementioned Increment Inode Manager, Increment Onode Manager, etc. These entities are the starting point for incremental computation, representing the initial set of entities for this incremental computation.

[0025] d. Merge the previously calculated entity set with the changed entity and the old entity to form a union. The union is a union of "the scope of the previous calculation + the entities changed in this calculation", in order to prepare for subsequent difference comparison and ensure that it is possible to identify which entities existed in the previous calculation but may have been deleted or modified in this calculation.

[0026] e. Extract the current entity corresponding to the entity in the union set from the current entity set to construct the current incremental calculation model.

[0027] f. Extract the previous calculation entity corresponding to the entity in the union set from the previous calculation entity set to construct the previous incremental calculation model.

[0028] g. Calculate the intersection of the current incremental calculation model and the previous incremental calculation model.

[0029] In this embodiment, a difference calculation algorithm is used to calculate the intersection of the current incremental calculation model and the previous incremental calculation model.

[0030] Specifically, by comparing the current entity set with the previously calculated entity set, the algorithms accurately identify entities that need to be recalculated. The difference calculation algorithm uses ID matching to find the intersection of the two sets, which represents the entities that need to be recalculated. The time complexity of the difference calculation algorithm is O(n+m), where n is the size of the source list and m is the size of the target list.

[0031] The difference calculation for entities can be performed simply by comparing strings using the entity ID. However, it is crucial to ensure the global uniqueness of the ID, for example, using UUID (Universally Unique Identifier) ​​in a single-machine environment or the Snowflake algorithm in a cluster environment. The incremental computing-based distributed display system command calculation method of this invention performs difference calculations such as between the "previous incremental calculation model" and the "current incremental calculation model." In this case, since the "previous incremental calculation model" belongs to the previous business data snapshot, it may have different ID configurations (same domain model) but different attributes compared to the "current incremental calculation model" (snapshot data and current data have different attributes, for example, the current incremental operation changed a certain attribute). Therefore, the essence of the difference calculation algorithm is to compare strings using IDs, rather than a complex mapping comparison of various attributes.

[0032] h. Based on the relationship links of entities, collect all related entities of the entities in the intersection.

[0033] In this embodiment, when collecting all associated entities of the entities in the intersection, the entities are processed in batches using a queue mechanism with a breadth-first search algorithm.

[0034] The system automatically collects all related entities that need to be recalculated based on the relationships between entities (i.e., dependency chains).

[0035] Specifically, the dependency chain: Window → Signal / Comp Signal → Inode (Window depends on signal, signal depends on input node); Window→Wall→Onode (The window belongs to the wall, and the wall contains output nodes). Signal→Comp Signal (bidirectional correlation between signal and composite signal); Inode→Signal→Window→Wall→Onode (the complete link from input node to output node); Onode→Wall→Window→Signal→Inode (reverse link from output node to input node).

[0036] Batch dependency collection starts from the initial changed entity and collects all related entities in batches. This method uses a breadth-first search (BFS) algorithm to ensure that all related entities are collected correctly.

[0037] The system employs queued processing, using a queue mechanism to process data in batches (maximum 1000 items per batch) to avoid memory overflow. This queued processing mechanism ensures manageable memory usage when handling large-scale systems.

[0038] The system employs an automatic deduplication mechanism using a Set collection to automatically remove duplicates and avoid redundant calculations. Each entity is processed only once, improving computational efficiency.

[0039] i. Merge the entities in the intersection with all the associated entities to construct the entity set to be calculated.

[0040] These intersecting entities are the core entities that need to be recalculated because their configurations may have changed. Instead of recalculating all entities, the intersection is used to precisely filter out the entities that truly need recalculation.

[0041] In this embodiment, when merging the entities in the intersection with all associated entities to construct the entity set to be calculated, the aging values ​​of the input and output nodes in all entities are traversed. Each time incremental calculation is triggered, the aging values ​​of all input and output nodes decrease. A node is marked as an aging node when the aging value of the input node or the output node is lower than a preset threshold. The aging nodes are incorporated into the set of entities to be computed.

[0042] Specifically, each node maintains an aging value (initially randomly generated). The random range of the initial aging value is dynamically configured based on the number of nodes in the environment and the expected aging. For example, in an environment with 1000 nodes, if it is expected that 5% of the nodes will undergo aging after each deployment, then the average aging value of the nodes would be 20. Random aging values ​​from 1 to 39 can be dynamically configured for each node. This ensures both high randomness and the 5% aging expectation.

[0043] Each time incremental computation is triggered, the aging value of all nodes is decremented by 1. If the aging value of a node is ≤ 0, it is marked as an aging node and added to the set of entities to be computed. This forces nodes that have not participated in incremental computation for a long time to recalculate and synchronize with the server, preventing inconsistencies between node and service states due to prolonged lack of communication. Aging nodes are not affected by this business change, but they must be forcibly included in this incremental computation. The aging decrement step is a fixed value, decreasing by 1 each time, and aging begins when the value reaches 0.

[0044] In this embodiment, the preset threshold is 0, which is a fixed value.

[0045] The aging reduction step size and preset threshold are both fixed values, and theoretically all scenarios can be configured using these fixed values.

[0046] When a node has undergone aging, its aging value will be reset after it is added to the entity to be calculated. The reset rules are the same as the initialization rules.

[0047] j. Input the set of entities to be calculated into the calculator to perform incremental calculation to obtain the calculation result, and maintain and update the set of entities calculated last time.

[0048] The set of entities to be computed forms a minimal, complete set of entities to be computed, containing only the necessary entities, which greatly reduces the amount of computation.

[0049] k. Based on the calculation results, generate system control commands. The calManager (the set of entities to be calculated) is handed over to the calculator (Core2dCalculator, i.e. the calculator in step j) to perform the actual incremental calculation, generating new configuration parameters or commands. That is, the final calculation result will be constructed as UDP control instructions.

[0050] After the calculation is complete, update the last manager (save the calculation results as a new snapshot) and clear the increment manager (or mark the process as complete).

[0051] When entities in a distributed display system change (e.g., are deleted), it is assumed that the previously calculated model data are InodeA, WindowA, OnodeA, and others. Among them, InodeA and OnodeA are the input and output nodes of the entity model, and WindowA is the abstract model window, which serves as the calculation bridge / channel between InodeA and OnodeA.

[0052] After WindowA is deleted in this operation, the calculation result obtained by the distributed display system command calculation method based on incremental calculation of this invention is InodeA and OnodeA (WindowA and others have been deleted or excluded). At this time, InodeA and OnodeA are sent as parameters to the calculator for calculation. Since InodeA and OnodeA lack Window as a calculation bridge / channel, "empty calculation" or "empty window calculation" will be performed on InodeA and OnodeA (InodeA and OnodeA do not perform related video stream forwarding calculations). Finally, the calculation result is sent down, which is represented by the deletion of the window.

[0053] The deletion operation does not rely on the specific model to be deleted being entered into the calculator for calculation, but rather on a new "empty calculation" performed throughout the entire video stream. This rule applies to the deletion calculation of all abstract and entity models.

[0054] The incremental computing-based command calculation method for distributed display systems of the present invention maintains the current entity set, the changed entity set, and the last calculated entity set, and uses intersection identification and dependency collection to perform incremental calculation only on the changed entities and their associated entities, thus avoiding the repeated processing of all entities in the full calculation, greatly improving the calculation efficiency and reducing the calculation overhead.

[0055] The incremental computing-based command calculation method for distributed display systems of the present invention can reduce the amount of computation by 60% to 90% in practical application scenarios (such as when only a few windows or signals change), and reduce the calculation time from seconds to milliseconds, significantly improving the system response speed.

[0056] The incremental computing-based command calculation method for distributed display systems of the present invention eliminates invalid calculations on unchanged entities such as input nodes, output nodes, signals, and walls, significantly reducing CPU and memory usage, saving system resources, and improving resource utilization.

[0057] The incremental computing-based command calculation method for distributed display systems of the present invention can support a 2-5 times increase in system scale under the same hardware conditions, and supports the deployment of larger-scale distributed video splicing display systems.

[0058] The incremental computing-based command calculation method for distributed display systems of the present invention is based on predefined entity relationship links (windows, signals, input nodes, windows, walls, output nodes, etc.), and automatically collects all related entities using breadth-first search and queue mechanisms. It eliminates the need for manual maintenance of dependencies, avoids human error, achieves intelligent dependency tracking, and ensures computational integrity.

[0059] The command calculation method of the distributed display system based on incremental computing of the present invention automatically removes duplicates through Set collection, and each entity is processed only once, so as to ensure the integrity and correctness of the calculation results.

[0060] The distributed display system command calculation method based on incremental calculation of the present invention introduces a node aging mechanism to ensure long-term state consistency. An aging value is maintained for each input node and output node, which is decremented with each incremental calculation. If the value is lower than the threshold, the node is forcibly included in the set of entities to be calculated.

[0061] The incremental computing-based command calculation method for distributed display systems of the present invention effectively prevents inconsistencies between the states of nodes that have not participated in calculations for a long time and the server, ensuring the accuracy and reliability of the system's long-term operation.

[0062] The response time of the command calculation method for the distributed display system based on incremental computing of the present invention is reduced from the second level to the millisecond level. Operators can receive instant feedback on operations such as window switching, signal source changes, and wall layout adjustments, which meets the stringent real-time requirements of scenarios such as large command centers, broadcast control, and conference systems.

[0063] The computational complexity of the incremental computation-based command calculation method for distributed display systems in this invention is reduced from O(n) of full computation to O(Δn) (Δn is the number of changed entities). The performance advantage becomes more obvious as the system scale increases, and it supports the elastic expansion of large-scale distributed display systems.

[0064] The above description is only a preferred embodiment of this application and an explanation of the technical principles used.

Claims

1. A command calculation method for a distributed display system based on incremental computation, characterized in that, Includes the following steps: The system manages the latest state of all entities in the distributed display system and generates the current entity set, records the entities that have changed and generates the changed entity set, saves the entity snapshot used in the last incremental calculation and generates the last calculation entity set, and simultaneously maintains the current entity set, the changed entity set, and the last calculation entity set; When an entity changes, the changed entity is recorded in the changed entity collection; The changed entity is obtained from the changed entity set, and the old entity corresponding to the changed entity is obtained from the previously calculated entity set; The previously calculated entity set is merged with the changed entity and the old entity to form a union set; Extract the current entity corresponding to the entity in the union set from the current entity set to construct the current incremental calculation model; Extract the previous computation entity corresponding to the entity in the union set from the previous computation entity set to construct the previous incremental computation model; Calculate the intersection of the current incremental calculation model and the previous incremental calculation model; Based on the relationship links of entities, collect all related entities of the entities in the intersection; The entities in the intersection are merged with all the associated entities to construct the entity set to be calculated; Input the set of entities to be calculated into the calculator to perform incremental calculations to obtain the calculation results, and maintain and update the set of entities from the previous calculation. Based on the calculation results, system control commands are generated; The core logical entities of a distributed display system include input nodes, output nodes, signals, composite signals, windows, and walls.

2. The command calculation method for a distributed display system based on incremental computation according to claim 1, characterized in that, When collecting all associated entities of the entities in the intersection, entities are processed in batches using a queue mechanism with a breadth-first search algorithm.

3. The command calculation method for a distributed display system based on incremental computation according to claim 1, characterized in that, The intersection of the current incremental calculation model and the previous incremental calculation model is obtained by using a difference calculation algorithm.

4. The command calculation method for a distributed display system based on incremental computation according to claim 1, characterized in that, When merging the entities in the intersection with all associated entities to construct the entity set to be calculated, the aging values ​​of the input and output nodes in all entities are traversed. Each time incremental calculation is triggered, the aging values ​​of all input and output nodes decrease. A node is marked as an aging node when the aging value of the input node or the output node is lower than a preset threshold. The aging nodes are incorporated into the set of entities to be computed.