Server integration system based on edge computing

Abstract

The invention relates to the technical field of computer task scheduling, in particular to a server integration system based on edge computing, which comprises a topological path delay analysis module, a multi-dimensional priority mapping scheduling module, a cross-architecture performance conversion module, a dynamic priority rearrangement module and a task migration optimization module. According to the method, more dynamic and flexible task scheduling is realized by accurately analyzing communication delay and network topology characteristics between edge nodes and based on comprehensive evaluation of node performance and delay weight, the intelligent level of task allocation is improved, and the limitation of static load detection is effectively avoided; the adaptability of the system to inter-node communication delay and execution time offset is enhanced, a task migration strategy is optimized, reasonable allocation and efficient execution of tasks among heterogeneous nodes are ensured, performance waste caused by improper resource scheduling is reduced, the utilization rate of resources and the overall performance of the system are improved, and the service life of the system is prolonged. And the dynamic response capability of task scheduling in the edge computing environment is enhanced.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of computer task scheduling, and particularly relates to a server integration system based on edge computing. BACKGROUND

[0002] The technical field of computer task scheduling relates to the overall planning and dynamic management of multiple types of computing, storage and network resources in a distributed computing environment, aiming to achieve efficient parallel execution of tasks among multiple nodes through a scientific scheduling mechanism. The core content of this field includes resource monitoring, task allocation strategy, load balancing, virtualized resource control and collaborative scheduling mechanism among multiple layers of nodes. Its main research directions cover performance evaluation of computing nodes, task execution priority setting, data flow path optimization and execution sequence synchronization, thereby providing a flexible and controllable task scheduling and resource allocation framework for distributed systems. In the context of edge computing, this technology is further extended to collaborative scheduling between edge and center nodes, enabling near-end execution and dynamic migration of computing tasks based on network topology and node performance.

[0003] Among them, the traditional server integration system refers to a system that utilizes the distributed computing capabilities of edge nodes to centrally schedule and uniformly manage the computing resources of multiple servers under the edge computing architecture. This system allocates tasks to be processed to different edge nodes through a task allocation unit, and then acquires resource usage information of multiple servers in real time through a node state acquisition unit. Based on resource mapping control logic, the correspondence between tasks and nodes is adjusted. The system also relies on a data interaction mechanism to realize information exchange and task transfer between nodes, ensuring the collaborative operation of multiple servers. The task allocation process of this system is mainly based on the self-performance parameters of nodes such as CPU occupancy, memory capacity and task queue length, while the consideration of communication path delay between nodes and network topology complexity is relatively limited. The overall scheduling mechanism focuses on static parameter matching and periodic load detection, lacking dynamic evaluation of the coupling relationship between task execution time offset and network latency.

[0004] The existing technology focuses on static parameter matching and periodic load detection in task scheduling and resource allocation, ignoring the dynamic changes in communication path delay between nodes and network topology complexity. This results in the inability to fully consider the complexity of the actual operating environment during task scheduling, especially in the context of edge computing. Traditional methods are difficult to effectively respond to the influence of communication delay between nodes and task execution time offset, further restricting the flexibility and optimization capability of the system. It is unable to achieve efficient migration and dynamic adjustment of tasks among heterogeneous nodes, causing uncertainty in task execution time and performance bottlenecks, and thus affecting the overall system efficiency and resource utilization. SUMMARY

[0005] The present application aims to solve the problems existing in the prior art, and proposes a server integration system based on edge computing.

[0006] To achieve the above-mentioned purpose, the present application adopts the following technical scheme, the server integration system based on edge computing comprises: The topology path delay analysis module obtains the communication path delay information between edge nodes, extracts the delay weight distribution characteristics between nodes, analyzes the mapping logic of delay weight and task dependency, and generates an edge network topology path cost quantization model; The multi-dimensional priority mapping scheduling module performs delay weight evaluation on the node dependency required for task execution based on the edge network topology path cost quantization model, records the joint priority model of nodes and paths, and establishes a task dependency and delay priority model; The cross-architecture performance conversion module collects the running performance parameters of heterogeneous nodes according to the task dependency and delay priority model, analyzes the combination characteristics of processing time, cache hit rate and core number, identifies the general load factor, and generates a heterogeneous node performance standardization measurement data set; The dynamic priority rearrangement module records the offset amount of the real-time start execution time and the planned execution time of the task in the multi-node based on the heterogeneous node performance standardization measurement data set, adjusts the priority order in the global task list, and generates a multi-architecture performance integration quantization evaluation table; The task migration optimization module analyzes the migration corresponding relationship between nodes and tasks according to the multi-architecture performance integration quantization evaluation table, generates a node load balancing and task migration decision graph, and generates a node load balancing and task migration decision graph.

[0007] As a further scheme of the present application, the edge network topology path cost quantization model comprises a delay weight distribution characteristic set, a node dependency relationship mapping table, and a joint priority model index, the task dependency and delay priority model comprises a node priority sequence, a path delay weight distribution graph, and a task dependency relationship mapping result, the heterogeneous node performance standardization measurement data set comprises a general load factor distribution list, a heterogeneous node performance mapping table, and a resource utilization rate standardization result, the multi-architecture performance integration quantization evaluation table comprises a task priority adjustment sequence, a time delay offset matrix distribution graph, and a global task list update result, and the node load balancing and task migration decision graph comprises a node identifier, a priority adjustment task grouping result, and a migration attribution relationship mapping result.

[0008] As a further scheme of the present application, the topology path delay analysis module comprises: The delay weight extraction submodule obtains the communication path delay information between edge nodes, performs a delay weight labeling operation, records the distribution characteristics of the delay weight, classifies the paths according to the weight by comparing the logical relationship of the delay weight between nodes, and obtains a delay weight distribution characteristic result; The dependency relationship analysis submodule extracts the logical mapping of the task dependency relationship between nodes according to the delay weight distribution characteristic result, intercepts the logical interval of the dependency relationship in the path, constructs a task dependency relationship mapping graph, and reorganizes the dependency relationship in combination with the path information, to obtain a task dependency relationship set. The weight matrix generation submodule rearranges the dependency relationship set through a logical sequence according to the task dependency relationship set, logically splices multiple dependency relationships of the same path, integrates the node information of each path, and obtains an edge network topology path cost quantization model.

[0009] As a further scheme of the application, the multi-dimensional priority mapping and scheduling module comprises: The delay weight evaluation submodule compares and sorts the delay weight of each path according to the logical label priority value in combination with the node dependency relationship required for task execution based on the edge network topology path cost quantization model, allocates a joint priority to the path in a high-low order, and obtains a delay weight evaluation index value. The priority model recording submodule identifies the path number set in the joint priority model according to the delay weight evaluation index value, respectively numbers each pair of adjacent paths and records the connection direction, integrates the priority edge information in combination with the node connection relationship in the path, and generates joint priority model graph data. The mapping matrix generation submodule collects the path number and adjacent path pair relationship in the connection edge according to the joint priority model graph data, stores the upstream and downstream relationship type and connection direction between each path according to the adjacent structure relationship, and obtains a task dependency and delay priority model.

[0010] As a further scheme of the application, the cross-architecture performance conversion module comprises: The performance parameter acquisition submodule acquires the running performance parameters of the heterogeneous nodes based on the task dependency and delay priority model, records the node number and performance type in the performance parameters, and generates a performance parameter distribution result in combination with the performance parameter type. The load factor construction submodule analyzes the combination characteristics of processing time, cache hit rate and core number according to the performance parameter distribution result, extracts the execution density and cache efficiency information of the performance parameters, and generates a general load factor distribution list. The performance conversion submodule assigns performance parameters to adaptive heterogeneous nodes according to the general load factor distribution list, records the correspondence between node numbers and performance parameter numbers, integrates performance allocation information, and generates a heterogeneous node performance standardization measurement dataset.

[0011] As a further scheme of the present application, the dynamic priority rearrangement module comprises: The time delay offset recording submodule collects the offset between the real-time starting execution time and the planned execution time of tasks in the nodes based on the heterogeneous node performance standardization measurement dataset, sequentially extracts the execution time information of each task, marks the node identification and time delay offset parameter to which the task belongs, and obtains the task number value; The priority adjustment submodule performs priority adjustment operations on tasks in the nodes according to the task number value, extracts the task number in the priority adjustment result, records the adjustment timestamp, compares it with the adjustment reference value, screens the task combinations that meet the conditions, and establishes a task priority adjustment set; The rearrangement scheme generation submodule queries the original task identification according to the task combination corresponding to the number according to the task priority adjustment set, integrates the task identification and adjustment timestamp information, and generates a multi-architecture performance integration quantitative evaluation table.

[0012] As a further scheme of the present application, the collection of the offset between the real-time starting execution time and the planned execution time of tasks in the nodes refers to that when the offset exceeds a preset threshold, the task is marked as a delayed task, and a corresponding delay record is generated, and if the offset is lower than the threshold, no marking is performed. The priority adjustment operation on the tasks in the nodes refers to that after the priority adjustment of the task corresponding to the task number value, if the adjusted priority reaches a preset standard, the adjustment result of the task is recorded, and the adjustment timestamp is saved, and if the priority does not reach the preset standard, no recording is performed.

[0013] As a further scheme of the present application, the task migration optimization module comprises: The node extraction submodule collects the node corresponding to each priority adjustment task according to the multi-architecture performance integration quantitative evaluation table, records the priority adjustment task number and the number of corresponding task sets associated in the node, determines the matching index between the priority adjustment task and the node, and obtains the node number value to which the priority adjustment task belongs; The task classification submodule classifies the priority adjustment tasks according to the node number value to which the priority adjustment task belongs, divides the corresponding tasks into each node, extracts the task number list belonging to each node, and obtains the task belonging strength value of the node; The migration structure generation submodule integrates the structural mapping of the nodes and subordinate task numbers according to the task belonging strength value of the node, outputs the node index, corresponding priority adjustment task number and task total number, determines the belonging of the node and the task, and generates a node load balancing and task migration decision graph.

[0014] Compared with the prior art, the application has the advantages and positive effects that: In the application, through accurate analysis of the communication delay between edge nodes and the network topology characteristics, based on the comprehensive evaluation of the node performance and delay weight, more dynamic and flexible task scheduling is realized, the intelligent level of task allocation is improved, the limitations of static load detection are effectively avoided, the adaptability of the system to the communication delay and execution time offset between nodes is enhanced, the task migration strategy is optimized, the reasonable allocation and efficient execution of tasks between heterogeneous nodes are ensured, the performance waste caused by improper resource scheduling is reduced, the utilization rate of resources and the overall performance of the system are improved, and the dynamic response capability of task scheduling in the edge computing environment is strengthened. BRIEF DESCRIPTION OF DRAWINGS

[0015] Figure 1 The system flowchart of the application is shown in the figure; Figure 2 The topology path delay analysis module flowchart in the application is shown in the figure; Figure 3 The multi-dimensional priority mapping scheduling module flowchart in the application is shown in the figure; Figure 4 The cross-architecture performance conversion module flowchart in the application is shown in the figure; Figure 5 The dynamic priority rearrangement module flowchart in the application is shown in the figure; Figure 6 The task migration optimization module flowchart in the application is shown in the figure. DETAILED DESCRIPTION

[0016] In order to make the purpose, technical scheme and advantages of the application clearer, the application will be further described in detail below in combination with the drawings and examples. It should be understood that the specific examples described herein are only used to explain the application and do not limit the application.

[0017] In the description of the present application, it should be understood that the terms "length", "width", "upper", "lower", "front", "back", "left", "right", "vertical", "horizontal", "top", "bottom", "inner", "outer" and the like indicate the orientation or positional relationship based on the orientation or positional relationship shown in the drawings, and are only for the convenience of describing the present application and simplifying the description, and do not indicate or imply that the device or element referred to must have a particular orientation, be constructed and operated in a particular orientation, and therefore cannot be understood as a limitation on the present application. In addition, in the description of the present application, the meaning of "a plurality of" is two or more, unless otherwise explicitly specified.

[0018] Please refer to Figure 1 The server integration system based on edge computing includes: The topology path delay analysis module obtains the communication path delay information between edge nodes, extracts the delay weight distribution characteristics between nodes, analyzes the mapping logic of delay weight and task dependency relationship, and generates an edge network topology path cost quantization model; The multi-dimensional priority mapping scheduling module performs delay weight evaluation on the node dependency relationship required by task execution based on the edge network topology path cost quantization model, records the joint priority model of nodes and paths, and establishes a task dependency and delay priority model; The cross-architecture performance conversion module collects running performance parameters of heterogeneous nodes according to the task dependency and delay priority model, analyzes the combination characteristics of processing time, cache hit rate and core number, identifies the general load factor, and generates a heterogeneous node performance standardization measurement data set; The dynamic priority rearrangement module records the offset amount of the real-time start execution time and the planned execution time of the task in the multi-node based on the heterogeneous node performance standardization measurement data set, adjusts the priority order in the global task list, and generates a multi-architecture performance integration quantization evaluation table; The task migration optimization module analyzes the migration corresponding relationship between nodes and tasks according to the multi-architecture performance integration quantization evaluation table, generates a node load balancing and task migration decision graph, and generates a node load balancing and task migration decision graph.

[0019] The edge network topology path cost quantification model includes a delay weight distribution feature set, a node dependency mapping table, and a joint priority model index. The task dependency and delay priority model includes a node priority sequence, a path delay weight distribution graph, and task dependency mapping results. The heterogeneous node performance standardization metric dataset includes a general load factor distribution list, a heterogeneous node performance mapping table, and resource utilization standardization results. The multi-architecture performance integration quantification evaluation table includes a task priority adjustment sequence, a delay offset matrix distribution graph, and global task list update results. The node load balancing and task migration decision graph includes node identifiers, priority adjustment task grouping results, and migration affiliation mapping results.

[0020] Please see Figure 2 The topology path delay analysis module includes: The delay weight extraction submodule obtains the communication path delay information between edge nodes, performs delay weight labeling operation, records the distribution characteristics of delay weight, and classifies the paths according to weight by comparing the logical relationship of delay weight between nodes to obtain the delay weight distribution characteristic result. Communication path latency information between multiple nodes in an edge computing network was obtained using network monitoring tools. In an industrial IoT scenario containing nodes A, B, C, D, E, and F, the latency was measured to be 12ms from node A to B, 18ms from A to C, 15ms from B to D, and 11ms from C to D by sending ICMP messages and calculating the average round-trip time. Subsequently, a latency weighting operation was performed, which defined latency weighting intervals. Referring to ETSIMEC's ​​definition of low-latency communication, a latency of less than 20ms was considered low latency and assigned a weight of 1; 20ms to 50ms was considered medium latency. A weight value of 2 is assigned, and a delay greater than 50ms is considered a high-latency interval, so a weight value of 3 is assigned. Accordingly, the delay weights for nodes A to B and A to C are both 1. Next, the distribution characteristics of the delay weights are recorded. For path A→B→D, its weight distribution characteristics are recorded as the sequence <1, 1>. By comparing the logical relationship of the delay weights between nodes, the paths are classified according to their weights. This comparison operation compares the weight sequences of the paths as a whole, and paths with the same weight sequence are grouped into one category. The weight sequences of paths A→B→D and A→C→D are both <1, 1>, so they are classified as "low-latency stable type". Finally, the result of the delay weight distribution characteristics is obtained.

[0021] The dependency resolution submodule extracts the logical mapping of task dependencies between nodes based on the delay weight distribution characteristics, extracts the logical intervals of the dependencies in the path, constructs a task dependency mapping graph, and reorganizes the dependencies in combination with path information to obtain a set of task dependencies. The system receives the latency weight distribution characteristic results, which indicate that path A→B→D belongs to the "low latency stable type". Then, it extracts the logical mapping of task dependencies between nodes. A video data analysis task flow contains subtasks T1, T2, and T3, with a dependency chain T1→T2→T3. During deployment, T1 is executed on node A, T2 on node B, and T3 on node D. This task dependency chain matches the node sequence of path A→B→D. Next, based on the logical intervals of the dependencies in the path, the system truncates the dependencies, mapping the T1→T2 dependency to the A→B segment of the path and the T2→T3 dependency to the B→D segment, constructing a task dependency mapping graph. This graph records the correspondence between task nodes and physical nodes, as well as the correspondence between task dependency arcs and physical path segments, in a graphical structure. Finally, the dependencies are reorganized based on the path information. This reorganization operation integrates all dependencies on the path and their corresponding physical segments, latency weights, and other information into a structured dataset, resulting in a task dependency set.

[0022] The weight matrix generation submodule rearranges the set of task dependencies in a logical order, logically concatenates multiple dependencies on the same path, and integrates the node information of each path to obtain the edge network topology path cost quantification model. The system receives a set of task dependencies, including dependency chains T1→T2→T3 on the path A→B→D and their corresponding physical segments A→B and B→D. The dependency set is then rearranged logically according to the task execution order to ensure that task dependencies align with the data flow along the physical path. Next, multiple dependencies on the same path are logically concatenated, combining dependencies T1→T2 on segment A→B and T2→T3 on segment B→D into a complete task flow. Node information for each path is integrated, including computing power, memory bandwidth, and energy consumption. For example, node A has a computing power of 10 GFLOPS, node B 15 GFLOPS, and node D 20 GFLOPS. Finally, the path cost is calculated based on this information. The cost quantification is achieved by adding the communication latency of the path segment to the processing cost of the endpoint node. The processing cost is determined by the node's computing power and the task's computational complexity. This process ultimately yields a quantitative path cost model for the edge network topology.

[0023] Please see Figure 3 The multi-dimensional priority mapping scheduling module includes: The latency weight evaluation submodule, based on the edge network topology path cost quantization model and combined with the node dependencies required for task execution, compares and sorts the latency weights of each path according to their logical label priority values, and assigns joint priorities to the paths in descending order, using the formula: ; Obtain the delay weight evaluation index value; in, Represents the index value for delayed weight evaluation. Representing the The first path The logical label priority value of each node. Representing the The average priority value of all logical labels of all nodes within the path. Representing the The first path The cost quantization value of each node, This represents the total number of nodes in the path. Based on the edge network topology path cost quantization model, the cost quantization values ​​of multiple path segments are obtained, such as the cost quantization value of segment A→B in path 1. The cost quantization value for segment B→D is 212. The priority value is 215. Simultaneously, each node on the path is assigned a logical label priority value based on the business importance of the task it carries. The quantification standard for this value is as follows: the priority value for critical tasks (such as emergency equipment shutdown control) is 5, for important tasks (such as production quality inspection) it is 3, and for ordinary tasks (such as equipment status monitoring) it is 1. Assuming that path 1 (A→B→D) carries the production quality inspection task flow, then the logical label priority values ​​of its nodes B and D are... and All are 3. Path 2 (A→C→D) carries the emergency shutdown control task flow for the equipment. The logical label priority values ​​of nodes C and D are 3. and Both are 5, in the formula middle, This represents the delay weight evaluation index value, used to measure the balance between priority and cost distribution within a path. Representing the The first path The logical label priority value of each node. It is the first The arithmetic mean of the logical label priority values ​​of all nodes within the path. It is the first Path number The quantified cost value of each node (referring to the cost of the path segment flowing into that node). This represents the total number of nodes in the path (excluding the starting node), and the summation symbol is used. This indicates that the absolute value is calculated by traversing all nodes along the path from the first intermediate node to the last node. The deviation between the priority of each node and the average priority of its path was calculated, reflecting the fluctuation of task priorities within the path. The term uses the square root of the cost quantification value as the weight, so that nodes with higher cost values ​​have a greater impact on the overall evaluation index due to their priority fluctuations. The total summation result is divided by the total number of nodes. This is an averaging process for weighted priority fluctuations. Taking path 1 as an example, the total number of nodes... Priorities of nodes B and D , Path average priority Cost quantification value , ; Substitute into the formula to calculate: ; Taking path 2 as an example, the cost of segment A→C is 18ms+T4 computational cost / computing power (C), and the cost of segment C→D is 11ms+T5 computational cost / computing power (D). Assume the calculated quantized cost values ​​are... , Priority of nodes C and D , Path average priority ; Substitute into the formula to calculate: ; Assume there exists another path 3, with node priorities as follows: , Then average priority The cost is , ; Then its index value is: ; The advantage of the formula is that by weighting and summing the priority deviation of multiple nodes on the path with the square root of the processing cost of the corresponding node, it can quantitatively evaluate the balance of task priority and resource cost distribution within the path. The smaller the G value, the more balanced the priority and cost distribution of the path, and the more suitable it is for carrying task chains. Conversely, it indicates that there are bottleneck nodes on the path where priority and cost do not match. The calculated delay weight evaluation index values ​​are G1=0, G2=0, and G3=28.97. This result shows that the internal priority distribution of path 1 and path 2 is very balanced, while the priority of path 3 fluctuates greatly and occurs on nodes with higher costs. Then, the paths are assigned joint priorities in order of index value from low to high. Path 1 and path 2 have the highest priority, followed by path 3. Finally, the delay weight evaluation index values ​​of the multi-path are obtained.

[0024] The priority model recording submodule evaluates the index value based on the delay weight, identifies the set of path numbers in the joint priority model, numbers and records the connection direction of each pair of adjacent paths, integrates the priority edge information by combining the node connection relationship in the path, and generates joint priority model graph data. Based on the aforementioned delay weight evaluation index values ​​(G1=0, G2=0, G3=28.97), the path number set in the joint priority model is identified as {path1, path2, path3} after being sorted in ascending order. Subsequently, each pair of adjacent paths with physically connected nodes is numbered and the connection direction is recorded. Path1 (A→B→D) and path2 (A→C→D) are "shared starting point" at node A and "shared ending point" at node D. Path2 and path3 (E→C→F) are connected at node C, specifically recorded as "path3 flows in, path2 flows out". Next, combined with the node connection relationships in the path, such as physical connections A→B, B→D, A→C, C→D, etc., the priority edge information is integrated. This information is a data structure containing adjacent path numbers, connected node numbers, connection directions, and task dependency relationship identifiers. By integrating the edge information of all paths, the joint priority model graph data is finally generated.

[0025] The mapping matrix generation submodule collects the path number and adjacent path pair relationship in the connection edge based on the joint priority model graph data, stores the upstream and downstream relationship type and connection direction between each path according to the adjacent structure relationship, and obtains the task dependency and delay priority model. The system receives joint priority model graph data, extracts path pairs (path 2, path 3) and their "connection at node C" relationship, and analyzes the adjacent structure relationship to determine that at node C, data flows in from the E→C segment of path 3 and flows out from the C→D segment of path 2. Based on this, path 3 is defined as upstream of path 2 at node C, and path 2 is defined as downstream of path 3. The upstream and downstream relationship type and connection direction between each path are then stored. Specifically, records <path 3, path 2, node C, upstream and downstream> are stored in the form of a matrix or association list. By traversing all such connection relationships, a topology structure describing the data flow logic and dependency relationship between all high-priority paths in the network is finally constructed to obtain the task dependency and delay priority model.

[0026] Please see Figure 4 The cross-architecture performance conversion module includes: The performance parameter acquisition submodule is based on a task dependency and delay priority model. It collects the running performance parameters of heterogeneous nodes, records the node number and performance type in the performance parameters, and generates the performance parameter distribution results by combining the performance parameter types. Based on the nodes (A, B, C, D, E, F) involved in the task dependency and latency priority model, where nodes A, C, and E are ARM architecture and nodes B, D, and F are x86 architecture, a performance monitoring agent was deployed on multiple nodes. Within the test window of the target task, data was collected at 1-second intervals and averaged to obtain processing time, cache hit rate, and number of cores. The average processing time of node B (x86) was 5ms, the L2 cache hit rate was 95%, and the number of physical cores was 8. The average processing time of node C (ARM) was 15ms, the L2 cache hit rate was 85%, and the number of physical cores was 4. Subsequently, the node number and performance type in the performance parameters were recorded. The collected data was associated with the node number and performance parameter type. Finally, combined with the performance parameter type, the same parameters of all nodes were integrated, as shown in the table below, to generate the performance parameter distribution results. As shown in Table 1, this table details the key performance parameters of multiple heterogeneous nodes in the network, providing a data foundation for the subsequent construction of load factors.

[0027] The load factor construction submodule analyzes the combined characteristics of processing time, cache hit rate and core count based on the performance parameter distribution results, extracts the execution density and cache efficiency information of the performance parameters, and generates a general load factor distribution list. Based on the performance parameter distribution results, execution density is defined as "cores / processing time", and caching efficiency is defined as "cache hit rate / 100". Then, the execution density and caching efficiency information of the performance parameters are extracted. Taking node B as an example, its execution density is 1.6 (tasks / ms) and caching efficiency is 0.95. Taking node C as an example, its execution density is approximately 0.267 (tasks / ms) and caching efficiency is 0.85. Next, the two indicators are weighted and summed to construct a general load factor. The weights are set based on benchmark experiments. The experimental results show that the influence of execution density is 0.7 and the influence of caching efficiency is 0.3. Based on this, the general load factor of node B is calculated to be 1.405, and the general load factor of node C is 0.4419. By performing the same calculation on all nodes, a general load factor distribution list is finally generated.

[0028] The performance conversion submodule allocates performance parameters to suitable heterogeneous nodes based on the general load factor distribution list, records the correspondence between node numbers and performance parameter numbers, integrates performance allocation information, and uses the following formula: ; Calculate the performance transition parameters between load factor and node load, and generate a standardized performance metric dataset for heterogeneous nodes. in, This parameter represents the performance conversion between load factor and node load. Representative Load Factor List The calculated value of the load factor. Represents node load metrics. The fit coefficient represents the load factor. Represents the node response coefficient. Represents the total number of load factor lists; Based on the general load factor distribution list, which represents the theoretical performance of a certain type of task to be executed on different nodes, assuming a set of tasks to be scheduled contains three tasks with different load characteristics, its load factor list... The calculated values ​​at nodes B and D are respectively , , Meanwhile, real-time load metrics of nodes are obtained through node monitoring agents. This metric represents the current CPU utilization of a node. Let's assume node B's CPU utilization is... Node D In the formula middle, Represents a performance conversion parameter that quantifies the workload of a specific task (by...). (reflected) and the real-time load of specific nodes (by) The compatibility between (reflection) It is the first in the list of load factors The load factor calculation value for each task. It is the load metric of the target node (normalized). The numerator of the fraction represents the total number of tasks in the load factor list. The absolute difference between the load factor of a single task and the node load was calculated, and the denominator was... It is the Euclidean norm of the difference between the load factor of all tasks and the node load, used for normalization. The entire fractional part calculates the task load factor. With nodes The relative magnitude of the load difference within the entire task set. This is the load factor adaptation coefficient, which is set according to the node's hardware architecture. Through experimental calibration, it has been found that the x86 architecture is more efficient in processing video encoding and decoding tasks. The value is 1.2, while for the ARM architecture it is 0.9. The node response coefficient reflects the node's historical average task response time, obtained by statistically analyzing the average response time of the past 100 tasks. Let's assume node B... Node D To perform the calculation, we first need to analyze the node load metrics. Normalize it to convert it from a percentage to a value with the same dimensions as the loading factor, setting the conversion relationship as D_norm = D / 50. , Now calculate task 2 ( Performance conversion parameters on node B ,at this time , , , ; Denominator calculation: ; ; The results show that the load of Task 2 is well matched with that of Node B, and this matching degree is particularly prominent in the task set. By calculating the P value for each task and each node, a matrix-form heterogeneous node performance normalization metric dataset is finally generated.

[0029] Please see Figure 5 The dynamic priority reordering module includes: The latency offset recording submodule is based on a heterogeneous node performance normalization metric dataset. It collects the offset between the real-time start execution time and the planned execution time of tasks in the node, extracts the execution time information of each task in turn, marks the node identifier and latency offset parameter of the task, and obtains the task number value. The offset between the real-time start time and the planned execution time of a task in the data collection node indicates that if the offset exceeds a preset threshold, the task will be marked as a delayed task and a corresponding delay record will be generated. If the offset is below the threshold, no marking will be performed. First, task scheduling is performed based on the aforementioned dataset. Then, using a task execution monitor deployed on a node (e.g., node B), the real-time start time of task T2 is collected. For example, if the planned execution timestamp for T2 is 14:00:00.500, and the actual start timestamp recorded by the monitor is 14:00:00.508, the time offset is calculated to be 8ms. Next, the execution time information for each task is extracted sequentially, and the node identifier and time offset parameters of the task are marked, for example, recorded as {Task: T2, Node: B, Offset: 8ms}. Finally, this offset is compared with a preset threshold... In the comparison, the threshold setting is based on the task's deadline requirement. For real-time control tasks that require a response within 100ms, the start delay threshold is set to 5ms. This setting has been tested through simulation. The test shows that when the start delay exceeds 5ms, there is a 90% probability that the task will eventually time out. Since the offset of task T2 is 8ms, which exceeds the preset threshold of 5ms, task T2 is marked as a delayed task, and a corresponding delay record is generated. If the offset of another task T3 is 3ms, which is lower than the threshold, it is not marked. All task numbers T2 marked as delayed tasks are extracted, and the task number value is obtained.

[0030] The priority adjustment submodule performs priority adjustment operations on the tasks in the node based on the task number value, extracts the task number from the priority adjustment result, records the adjustment timestamp, compares it with the adjustment baseline value, filters out the task combinations that meet the conditions, and establishes a task priority adjustment set. Performing priority adjustment operation on tasks in a node means that after the priority of the task corresponding to the task number value is adjusted, if the adjusted priority reaches the preset standard, the adjustment result of the task is recorded and the adjustment timestamp is saved; if the priority does not reach the preset standard, no record is made. Based on the delayed task number T2, a priority adjustment operation is performed on task T2 in node B. Specifically, this operation increases its priority value in the operating system kernel scheduling queue from 10 to 5 (lower values ​​indicate higher priority). After the priority adjustment of task T2, it is checked whether the adjusted priority meets a preset standard. This standard is defined as requiring a priority increase to enter the "real-time priority" range, i.e., a priority value less than 8. Since the adjusted priority 5 is less than 8, the preset standard is met. Therefore, the task adjustment result is recorded, including the task number T2 and the adjusted priority 5, and the adjustment is saved. The timestamp, for example, 14:00:00.620, is used. If the adjusted priority is 9, which does not meet the standard, it is not recorded. The priority change (10→5, change of 5) is compared with an adjustment baseline value. This baseline value is set to filter out minor and invalid adjustments. Its value is set to 2 based on the statistical analysis of historical scheduling data. That is, only adjustments with a priority value reduction of more than 2 are considered valid adjustments. Since 5>2, this adjustment is a valid adjustment. Finally, all the filtered tasks (T2 in this example) and their adjustment information are combined to establish a task priority adjustment set.

[0031] The rearrangement scheme generation submodule adjusts the set according to the task priority, queries the original task identifier according to the task combination corresponding to the number, integrates the task identifier and adjustment timestamp information, and generates a multi-architecture performance integration quantitative evaluation table. The system receives a set of task priority adjustments, which includes task number T2 and its adjustment timestamp 14:00:00.620. Then, it queries the original task identifier defined during the initial task deployment based on the number T2. For example, it queries the mapping table to find that T2 corresponds to the specific business task "Video Stream_001_Feature Extraction". Next, it integrates the task identifier "Video Stream_001_Feature Extraction", adjustment timestamp 14:00:00.620, priority before and after adjustment (10→5), the node to which it belongs (B), the reason for the delay (startup offset 8ms), and other information, and organizes the information into a structured row of data. By performing the same operation on all tasks that have undergone priority adjustments, a multi-architecture performance integration quantitative evaluation table is finally generated, as shown in Table 2 below. See Table 2, which records all valid priority adjustment events during the dynamic reordering process, providing detailed quantitative basis for subsequent task migration decisions.

[0032] Please see Figure 6 The task migration optimization module includes: The node extraction submodule collects the nodes corresponding to each priority adjustment task based on the multi-architecture performance integration quantitative evaluation table, records the priority adjustment task numbers associated with the nodes and the number of their corresponding task sets, determines the matching index between priority adjustment tasks and nodes, and obtains the node number value to which the priority adjustment task belongs. Based on the multi-architecture performance integration quantitative evaluation table, the nodes corresponding to each priority adjustment task are collected. For example, the node corresponding to the task "Video Stream_001_Feature Extraction" is B, and the node corresponding to the task "Control Signaling_005_Parsing" is C. Subsequently, the priority adjustment task numbers and their quantities associated with each node are recorded. Specifically, node B is associated with one priority adjustment task, and node C is also associated with one priority adjustment task. If more tasks occurring on node B are adjusted subsequently, the count value of that node will increase. Then, the matching index between the priority adjustment task and the node is determined. This index is a key-value pair structure, where the key is the node number and the value is the list of tasks that have undergone priority adjustment on that node, for example, {B:("Video Stream_001_Feature Extraction"], C:("Control Signaling_005_Parsing"]}. All keys (i.e., node numbers B and C) in this structure are extracted to obtain the node number value to which the priority adjustment task belongs.

[0033] The task classification submodule adjusts the node number value of the task based on priority, and divides the corresponding tasks into each node according to the priority of task classification. It extracts the task number list of each node and obtains the task affiliation strength value of the node. Based on node numbers B and C, tasks are assigned to each node according to priority adjustment task classification. "Video Stream_001_Feature Extraction" is assigned to node B, and "Control Signaling_005_Parsing" is assigned to node C. This extracts a list of task numbers belonging to each node. The list for node B is ["Video Stream_001_Feature Extraction"], and the list for node C is ["Control Signaling_005_Parsing"]. Next, the task assignment strength value of each node is calculated as "number of tasks with priority adjustments on the node / total number of tasks running on the node". If node B has 5 tasks running, and 1 of them has a priority adjustment, then node B's task assignment strength value is 0.2. If node C has 3 tasks running, and 1 of them has a priority adjustment, then node C's task assignment strength value is approximately 0.33. Finally, the task assignment strength value of each node is obtained.

[0034] The migration structure generation submodule maps and integrates nodes with their subordinate task numbers based on the task affiliation strength value of the nodes, outputs the node index, the corresponding priority adjustment task number and the total number of tasks, determines the affiliation of nodes and tasks, and generates a node load balancing and task migration decision graph. Based on the task attribution strength values ​​of the nodes (0.2 for B, 0.33 for C), and combined with the real-time load conditions of the nodes (e.g., node B has a load rate of 90% and node C has a load rate of 60%), a migration decision threshold is set. This threshold includes two dimensions: task attribution strength value and node load rate. When a node's task attribution strength value is higher than 0.3 and its load rate is higher than 85%, a migration decision is triggered. In this example, node C's strength value of 0.33 is higher than the threshold, but its load rate of 60% is lower than the threshold, so migration is not triggered. Node B's load rate of 90% is higher than the threshold. However, its strength value of 0.2 does not reach the threshold and does not trigger migration. If the strength value of node B becomes 0.4 (for example, 2 out of 5 tasks have their priorities adjusted), then both conditions are met. At this time, node B and its subordinate tasks such as "video stream_001_feature extraction" are identified as objects to be migrated. The decision results are output in the form of a graph. Node B in the graph is marked as "high load - unstable" and is accompanied by its task list, total number of tasks 5, and suggested target nodes for migration (such as node D with lower load). A node load balancing and task migration decision graph is generated.

[0035] The above are merely preferred embodiments of the present invention and are not intended to limit the present invention in any other way. Any person skilled in the art may make changes or modifications to the above-disclosed technical content to create equivalent embodiments that can be applied to other fields. However, any simple modifications, equivalent changes, and modifications made to the above embodiments based on the technical essence of the present invention without departing from the scope of the present invention shall still fall within the protection scope of the present invention.

Claims

1. A server consolidation system based on edge computing, characterized in that, The system includes: The topology path delay analysis module obtains communication path delay information between edge nodes, extracts the delay weight distribution characteristics between nodes, parses the mapping logic between delay weight and task dependency, and generates an edge network topology path cost quantification model. The multidimensional priority mapping scheduling module evaluates the delay weight of the node dependencies required for task execution based on the edge network topology path cost quantification model, records the joint priority model of nodes and paths, and establishes a task dependency and delay priority model. The cross-architecture performance conversion module collects the running performance parameters of heterogeneous nodes based on the task dependency and latency priority model, analyzes the combined characteristics of processing time, cache hit rate and core count, identifies common load factors, and generates a standardized performance measurement dataset for heterogeneous nodes. The dynamic priority reordering module, based on the heterogeneous node performance standardization metric dataset, records the offset between the real-time start execution time and the planned execution time of tasks in multiple nodes, adjusts the priority order in the global task list, and generates a multi-architecture performance integration quantitative evaluation table. The task migration optimization module uses the multi-architecture performance integration and quantitative evaluation table to count the nodes to which priority adjustment tasks belong, assigns priority adjustment tasks to the corresponding nodes, analyzes the migration correspondence between nodes and tasks, and generates a node load balancing and task migration decision graph.

2. The server consolidation system based on edge computing according to claim 1, characterized in that, The edge network topology path cost quantification model includes a latency weight distribution feature set, a node dependency mapping table, and a joint priority model index. The task dependency and latency priority model includes a node priority sequence, a path latency weight distribution graph, and task dependency mapping results. The heterogeneous node performance standardization metric dataset includes a general load factor distribution list, a heterogeneous node performance mapping table, and resource utilization standardization results. The multi-architecture performance integration quantification evaluation table includes a task priority adjustment sequence, a latency offset matrix distribution graph, and global task list update results. The node load balancing and task migration decision graph includes node identifiers, priority adjustment task grouping results, and migration affiliation mapping results.

3. The server consolidation system based on edge computing according to claim 1, characterized in that, The topology path delay analysis module includes: The delay weight extraction submodule obtains the communication path delay information between edge nodes, performs delay weight labeling operation, records the distribution characteristics of delay weight, and classifies the paths according to weight by comparing the logical relationship of delay weight between nodes to obtain the delay weight distribution characteristic result. The dependency parsing submodule extracts the logical mapping of task dependencies between nodes based on the delay weight distribution feature results, extracts the logical interval of the dependency in the path, constructs a task dependency mapping graph, and reorganizes the dependency in combination with path information to obtain a set of task dependencies. The weight matrix generation submodule rearranges the set of dependencies according to the task dependency set in a logical order, logically concatenates multiple dependencies of the same path, and integrates the node information of each path to obtain the edge network topology path cost quantization model.

4. The server consolidation system based on edge computing according to claim 3, characterized in that, The multi-dimensional priority mapping scheduling module includes: The delay weight evaluation submodule, based on the edge network topology path cost quantization model and combined with the node dependencies required for task execution, compares and sorts the delay weight of each path according to its logical label priority value, assigns joint priority to the paths in descending order, and obtains the delay weight evaluation index value. The priority model recording submodule evaluates the index value based on the delay weight, identifies the set of path numbers in the joint priority model, numbers and records the connection direction of each pair of adjacent paths, integrates the priority edge information by combining the node connection relationship in the path, and generates joint priority model graph data. The mapping matrix generation submodule collects the path number and adjacent path pair relationship in the connection edge according to the joint priority model graph data, stores the upstream and downstream relationship type and connection direction between each path according to the adjacent structure relationship, and obtains the task dependency and delay priority model.

5. The server consolidation system based on edge computing according to claim 4, characterized in that, The cross-architecture performance conversion module includes: The performance parameter acquisition submodule collects the running performance parameters of heterogeneous nodes based on the task dependency and delay priority model, records the node number and performance type in the performance parameters, and generates the performance parameter distribution results by combining the performance parameter types. The load factor construction submodule analyzes the combined characteristics of processing time, cache hit rate and core count based on the performance parameter distribution results, extracts the execution density and cache efficiency information of the performance parameters, and generates a general load factor distribution list. The performance conversion submodule allocates performance parameters to suitable heterogeneous nodes according to the general load factor distribution list, records the correspondence between node numbers and performance parameter numbers, integrates performance allocation information, and generates a heterogeneous node performance standardized metric dataset.

6. The server consolidation system based on edge computing according to claim 5, characterized in that, The dynamic priority reordering module includes: The delay offset recording submodule, based on the heterogeneous node performance normalization metric dataset, collects the offset between the real-time start execution time and the planned execution time of tasks in the node, extracts the execution time information of each task in sequence, marks the node identifier and delay offset parameter of the task, and obtains the task number value. The priority adjustment submodule performs priority adjustment operations on the tasks in the node based on the task number value, extracts the task number from the priority adjustment result, records the adjustment timestamp, compares it with the adjustment baseline value, filters out the task combinations that meet the conditions, and establishes a task priority adjustment set. The rearrangement scheme generation submodule adjusts the set according to the task priority, queries the original task identifier according to the task combination corresponding to the number, integrates the task identifier and adjustment timestamp information, and generates a multi-architecture performance integration quantitative evaluation table.

7. The server consolidation system based on edge computing according to claim 6, characterized in that, The offset between the real-time start time and the planned execution time of a task in the acquisition node refers to the fact that if the offset exceeds a preset threshold, the task will be marked as a delayed task and a corresponding delay record will be generated; if the offset is below the threshold, no marking will be performed. The operation of adjusting the priority of tasks in the node means that when the priority of the task corresponding to the task number value is adjusted, if the adjusted priority reaches the preset standard, the adjustment result of the task is recorded and the adjustment timestamp is saved; if the priority does not reach the preset standard, no record is made.

8. The server consolidation system based on edge computing according to claim 6, characterized in that, The task migration optimization module includes: The node extraction submodule collects the nodes corresponding to each priority adjustment task according to the multi-architecture performance integration quantitative evaluation table, records the priority adjustment task numbers associated with the nodes and the number of their corresponding task sets, determines the matching index between priority adjustment tasks and nodes, and obtains the node number value to which the priority adjustment task belongs. The task classification submodule adjusts the task-assigned node number value based on the priority, and divides the corresponding tasks into each node according to the priority-adjusted task classification. It extracts the task number list of each node and obtains the task affiliation intensity value of the node. The migration structure generation submodule integrates the node and its subordinate task numbers through structural mapping based on the task affiliation strength value of the node, outputs the node index, the corresponding priority adjustment task number and the total number of tasks, determines the affiliation of the node and the task, and generates a node load balancing and task migration decision graph.

Images