A load-aware edge computing node collaborative processing system

Abstract

This invention relates to the field of digital computer combinatorial processing technology, specifically to a load-aware edge computing node collaborative processing system. The system includes a task density construction module, a current sequence extraction module, a state transition identification module, a synchronization trigger generation module, and a processing chain construction module. In this invention, task features are mapped to the system load distribution through task number construction and merging. Dynamic features of task execution are extracted using a splicing and alignment mechanism based on node current disturbances. State transition boundaries are constructed based on the differences between the beginning and end of currents between tasks to identify key change points. A node number consistency identification mechanism extracts synchronization trigger positions to ensure collaborative execution. An execution chain is constructed based on task sequence rearrangement and number binding, enabling task scheduling to perceive node operating states and load changes, thereby improving task identification accuracy, execution timing management capabilities, and collaborative organization efficiency.

Description

Technical Field

[0001] This invention relates to the field of digital computer combinatorial processing technology, and in particular to a load-aware edge computing node collaborative processing system. Background Technology

[0002] The field of digital computing combined processing technology involves the collaborative operation and resource sharing among multiple digital computing devices with computing capabilities. Its core aspects include distributed scheduling of computing tasks, data communication mechanisms between multiple computing units, task load balancing, system redundancy and fault tolerance. This field aims to improve data processing capabilities and efficiency by having multiple computers or edge devices work collaboratively. Common application scenarios include distributed computing systems, edge computing architectures, cloud-edge collaborative processing platforms, and system structures and implementation mechanisms for multiple computing units to jointly execute complex tasks. Among them, traditional edge computing node collaborative processing systems refer to systems in edge computing architectures where different computing nodes collaborate to process tasks through fixed strategies. Task scheduling is usually accomplished through preset node processing capabilities or static load allocation mechanisms. The task scheduling is based on the processing capability estimation of node configuration parameters, and then the central node or main control system divides the tasks to be processed into various edge nodes for execution according to the set allocation algorithm. After the tasks are processed, the central node collects the results and outputs them uniformly. In this approach, the collaborative relationship between nodes is usually fixed, and there is a lack of awareness of the actual operating status and dynamic load changes of the nodes.

[0003] Existing edge computing node task scheduling is based on static strategies, relying on fixed configuration parameters to estimate processing capacity. It ignores the dynamic state changes of nodes during operation and lacks means to identify the actual task execution intensity between nodes. As a result, the scheduling scheme cannot be effectively adjusted according to the task arrival order and actual complexity. The state fluctuations during task execution cannot be identified by the system in real time. The collaboration between nodes lacks precision and synchronization support. Resource allocation often deviates from the actual needs of task execution load and is difficult to adapt to situations where task triggering timing is misaligned or node state changes are frequent in multi-node environments. This can easily lead to problems such as unbalanced execution rhythm, sudden increase in energy consumption, and system response lag. Summary of the Invention

[0004] To address the technical problems existing in the prior art, embodiments of the present invention provide a load-aware edge computing node collaborative processing system. One aspect of the system is a load-aware edge computing node collaborative processing system, comprising:

[0005] The task density construction module analyzes the number of instructions and arrival order of tasks in the task queue, numbers them according to the node processing channel allocation rules, establishes the correspondence between task number and the number of instructions and the arrival order, merges adjacent numbered tasks that arrive consecutively, and constructs a task load distribution structure.

[0006] The current sequence extraction module collects the node current change records corresponding to the task number in the task load distribution structure, splices the continuous current records of the same task number, aligns the sequence according to the task number, and generates a node current perturbation sequence.

[0007] The state transition identification module compares the differences between the beginning and end of the current segments corresponding to adjacent task numbers in the node current disturbance sequence, and combines the continuous interval of the task number in the task load distribution structure to filter the task numbers where the differences occur, and generates a set of state transition boundary numbers.

[0008] The synchronization trigger generation module calls all task numbers in the state switching boundary number set, compares the synchronization occurrence of the task numbers in the nodes, writes a unified identifier and sorts the order to generate a multi-node synchronization trigger number set.

[0009] The processing chain construction module rearranges the execution order of corresponding tasks according to the set of multi-node synchronous trigger numbers, binds the rearranged task order with the number identifier, and connects them in series according to the execution order of the nodes to construct a load-aware edge computing collaborative processing task sequence.

[0010] As a further embodiment of the present invention, the task load distribution structure includes a mapping relationship between task number and instruction quantity, a mapping relationship between task number and arrival order, and a number merging identifier for consecutive tasks; the node current disturbance sequence includes a continuous current segment splicing result, a task number alignment sequence, and a current disturbance time period identifier; the state switching boundary number set includes the corresponding number for the difference between the first and last currents, the numbering duration interval filtering result, and the current mutation concentrated number identifier; the multi-node synchronous trigger number set includes a number consistency identifier between nodes, a unified number identifier sequence, and a numbering order arrangement structure; and the load-aware edge computing collaborative processing task sequence includes a rearranged task execution order, a number and identifier binding structure, and a serial execution path between nodes.

[0011] As a further aspect of the present invention, the synchronous occurrence of the task number in the comparison node refers to comparing the simultaneous occurrence positions of the same task number in the current disturbance sequence in the node to determine the synchronous triggering characteristics.

[0012] As a further aspect of the present invention, the task number for which the difference occurs is selected by identifying the task number with the change in current based on the difference between the beginning and end currents of adjacent task number segments in the current disturbance sequence, and in combination with the duration of the task number in the task load distribution structure.

[0013] As a further aspect of the present invention, the task density construction module includes:

[0014] The task instruction statistics submodule extracts the timestamp and instruction count based on the arrival order of tasks in the task queue and the corresponding number of instructions, calls the channel allocation rules to assign numbers to tasks, and generates a task number mapping matrix.

[0015] The task number merging submodule detects consecutively numbered tasks and judges channel consistency based on the number and arrival order in the task number mapping matrix, and merges the task numbers that meet the conditions to generate a consecutive task number merging table.

[0016] The load distribution generation submodule calls the number range and total number of instructions in the continuous task number merging table, calculates the processing intensity of the channel per unit time, constructs a two-dimensional matrix of task number and channel number, and generates the task load distribution structure.

[0017] As a further aspect of the present invention, the current sequence extraction module includes:

[0018] The task sequence parsing submodule obtains the start and end time periods corresponding to the tasks based on the task number sequence recorded in the task load distribution structure, collects the current change records of the nodes during the task number execution time period, marks and classifies the current sampled values ​​according to the task number sequence, and generates a task number current index table.

[0019] The current recording splicing submodule determines the continuity of timestamps based on multiple continuous current records associated with the same task number in the task number current index table, and splices the first and last current sampling sequences that meet the continuity conditions to generate a set of numbered continuous current sequences.

[0020] The sequence alignment generation submodule calls the continuous current sequence corresponding to the task number in the numbered continuous current sequence set, performs sequence position calibration and length normalization processing according to the task number order, performs sequence alignment of the differentiated task number current sequences, and generates the node current perturbation sequence.

[0021] As a further aspect of the present invention, the state transition identification module includes:

[0022] The current difference calculation submodule extracts the first and last values ​​of adjacent numbered tasks based on the current segments corresponding to the task numbers in the node current disturbance sequence, calculates the difference between the first and last segments, records the difference list in the order of task numbers, and generates a current difference vector between tasks.

[0023] The task interval matching submodule calls the difference value corresponding to the number in the inter-task current difference vector, and combines it with the start and end positions of the continuous intervals of the same task number in the task load distribution structure to perform interval cross-location of the numbers with concentrated differences, obtain the distribution characteristics of the number intervals, and generate a task number interval mapping table.

[0024] The state boundary filtering submodule determines the relationship between the number jump frequency and the interval span based on the number position and current difference distribution in the task number interval mapping table, filters task numbers with concentrated differences and frequent changes across intervals, and generates a set of state switching boundary numbers.

[0025] As a further aspect of the present invention, the synchronization trigger generation module includes:

[0026] The number node matching submodule calls all task numbers in the state switching boundary number set, compares the existence of the same number in the node task execution record, extracts the task numbers that appear repeatedly in all nodes, summarizes them in order of number to form a unified set, and generates a list of node shared numbers.

[0027] The identifier sorting and encoding submodule rearranges the positions of nodes according to the task numbers in the node shared number list and the first appearance time of each node, constructs a unified number sorting structure between nodes, and adds a unified identifier to each group of numbers to generate a synchronization identifier order mapping table.

[0028] The trigger number output submodule calls the unified number sequence corresponding to the synchronization identifier sequence mapping table, integrates the mapping content by node group, extracts the number set after synchronization calibration, and generates a multi-node synchronization trigger number set.

[0029] As a further aspect of the present invention, the processing chain construction module includes:

[0030] The task order reordering submodule extracts the original execution order of the corresponding tasks on the nodes based on the task numbers recorded in the multi-node synchronization trigger number set, rearranges them according to the number order, establishes a mapping relationship between task numbers and reordering order, and generates a synchronization task order matrix.

[0031] The number binding encoding submodule calls the task rearrangement result in the synchronous task sequence matrix, adds the corresponding sequence identifier code to the number, forms a one-to-one correspondence structure between task number and sequence code, and stores the bound content into the node structure table to generate a task number sequence mapping table.

[0032] The node concatenation generation submodule concatenates nodes according to the task arrangement and sequence identifier of the nodes in the task number sequence mapping table, establishes a cross-node processing relationship graph, extracts the continuous transfer path of tasks between nodes, and generates a load-aware edge computing collaborative processing task sequence.

[0033] As a further aspect of the present invention, the continuous transfer path of the task between nodes refers to the processing path in which the tasks are sequentially transferred between nodes according to the execution order of the tasks on the differentiated nodes in the task number order mapping table.

[0034] The beneficial effects of the technical solutions provided by the embodiments of the present invention include at least the following:

[0035] By constructing and merging task numbers, task features are mapped to the system load distribution. Combined with the splicing and alignment mechanism of node current disturbances, dynamic features of task execution are extracted. The state transition boundary is constructed based on the difference between the beginning and end of the current between tasks to identify key change points. The node number consistency identification mechanism extracts the synchronous trigger position to ensure execution coordination. Based on task sequence rearrangement and number binding, an execution chain is constructed to realize the perception of node running status and load changes in task scheduling, thereby improving task identification accuracy, execution timing management capabilities, and collaborative organization efficiency. Attached Figure Description

[0036] To more clearly illustrate the technical solutions in the embodiments of the present invention, the accompanying drawings used in the description of the embodiments will be briefly introduced below. Obviously, the accompanying drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0037] Figure 1 This is a schematic diagram of the system of the present invention;

[0038] Figure 2 This is a flowchart of the task density construction module of the present invention;

[0039] Figure 3 This is a flowchart of the current sequence extraction module of the present invention;

[0040] Figure 4 This is a flowchart of the state transition recognition module of the present invention;

[0041] Figure 5 This is a flowchart of the synchronous trigger generation module of the present invention;

[0042] Figure 6 This is a flowchart of the chain construction module of the present invention. Detailed Implementation

[0043] The technical solution of the present invention will now be described with reference to the accompanying drawings.

[0044] To make the technical problems, technical solutions and advantages of the present invention clearer, a detailed description will be given below in conjunction with the accompanying drawings and specific embodiments.

[0045] This invention provides a load-aware edge computing node collaborative processing system, such as... Figure 1 The diagram shown illustrates a load-aware edge computing node collaborative processing system, which includes:

[0046] The task density construction module analyzes the number of instructions and arrival order of tasks in the task queue, divides tasks into numbers according to the allocation rules of node processing channels, establishes a correspondence between task numbers and the number of instructions and arrival order, and performs number merging processing on consecutively arriving tasks to construct a task load distribution structure.

[0047] The current sequence extraction module collects the current change records of nodes during the corresponding task execution period based on the task number order recorded in the task load distribution structure, splices the continuous current records corresponding to the same number, and completes the sequence alignment according to the task number to generate the node current perturbation sequence.

[0048] The state transition identification module compares the differences between the beginning and end of the current segments corresponding to adjacent task numbers in the node current disturbance sequence. At the same time, it combines the continuous intervals of the same task number in the task load distribution structure to filter the task numbers that appear in the difference set and generate a set of state transition boundary numbers.

[0049] The synchronous trigger generation module calls all task numbers in the state switching boundary number set, compares the occurrence of the same number within the node range, writes the numbers that appear simultaneously in the node into a unified identifier, and organizes the order of the identifiers to generate a multi-node synchronous trigger number set.

[0050] The processing chain construction module rearranges the execution order of corresponding tasks based on the task numbers recorded in the multi-node synchronous trigger number set, binds the rearranged task order with the number identifier, and connects them in series according to the execution order of the nodes to build a load-aware edge computing collaborative processing task sequence.

[0051] The task load distribution structure includes the mapping relationship between task number and instruction quantity, the mapping relationship between task number and arrival order, and the number merging identifier of consecutive tasks. The node current disturbance sequence includes the splicing result of consecutive current segments, the task number alignment sequence, and the current disturbance time period identifier. The state switching boundary number set includes the corresponding number of the difference between the first and last currents, the numbering duration interval filtering result, and the number identifier of the current mutation concentration. The multi-node synchronous trigger number set includes the number consistency identifier between nodes, the unified number identifier sequence, and the numbering order arrangement structure. The load-aware edge computing collaborative processing task sequence includes the rearranged task execution order, the number and identifier binding structure, and the serial execution path between nodes.

[0052] Specifically, such as Figure 2 As shown, the task density building module includes:

[0053] The task instruction statistics submodule extracts the timestamp and instruction count based on the arrival order of tasks in the task queue and the corresponding number of instructions, calls the channel allocation rules to assign numbers to tasks, and generates a task number mapping matrix.

[0054] First, a high-frequency polling mechanism scans the task queue, which uses a first-in, first-out (FIFO) data structure to store pending computation tasks. An internal timestamp extraction unit immediately reads the system's high-precision clock and records the task's arrival timestamp, accurate to the microsecond level, the moment a task is pushed into the queue. Simultaneously, an instruction counting unit performs deep analysis of the task packets, identifying and accumulating the number of opcodes by traversing the binary code segments of each task, thus quantifying the number of instructions for each task. Based on this, a channel allocation rule invocation unit is activated. This unit presets a load balancing algorithm, such as a weighted round-robin scheduling strategy. This strategy maps tasks to specific computation channels based on the real-time occupancy status feedback of each computing channel and the total instruction weight of the tasks. Specifically, the channel allocation rule sets a channel capacity threshold; when the total number of instructions allocated to a channel exceeds the capacity threshold, new tasks are automatically redirected to the next idle or low-load channel. Finally, a numbering allocation unit generates a unique task number based on the task's arrival order in the queue and the assigned channel index. The task number uses a combined encoding method, including a time sequence identifier and a channel identifier. Finally, the matrix generation unit integrates the task number, arrival timestamp, number of instructions, and assigned channel ID to construct a dynamically updated task number mapping matrix. This matrix is ​​stored in memory as a two-dimensional array, with row indices corresponding to the task arrival sequence and column indices storing the four key parameters mentioned above.

[0055] To ensure the accuracy and feasibility of the above logic, the parameter acquisition and processing process is illustrated below through a specific example. Assume the system receives three consecutively arriving tasks, labeled Task A, Task B, and Task C. The system clock records the arrival time of Task A as 1000 microseconds, Task B as 1005 microseconds, and Task C as 1012 microseconds. The instruction counting unit, through analysis, finds that Task A contains 500 basic arithmetic instructions, Task B contains 1200 floating-point arithmetic instructions, and Task C contains 800 logical judgment instructions. The system's preset channel allocation capacity threshold is 2000 instructions. The channel allocation unit first allocates Task A to Channel 1, at which point Channel 1 has a cumulative load of 500 instructions. Next, Task B is processed. If allocated to Channel 1, the cumulative load would reach 1700 instructions, which does not exceed the 2000 instruction threshold, so Task B is also allocated to Channel 1. When processing Task C, if it continues to be allocated to Channel 1, the cumulative load would reach 2500 instructions, exceeding the threshold. Therefore, the system allocates Task C to Channel 2 according to the rules. The numbering allocation unit generates task numbers accordingly: Task A is numbered "01-001" (Channel 1 - Sequence Number 1), Task B is numbered "01-002", and Task C is numbered "02-001". The final generated task number mapping matrix contains three rows of data: the first row records "01-001, 1000, 500, Channel 1", the second row records "01-002, 1005, 1200, Channel 1", and the third row records "02-001, 1012, 800, Channel 2".

[0056] The task number merging submodule detects consecutively numbered tasks and judges channel consistency based on the number and arrival order in the task number mapping matrix, and merges the task numbers that meet the conditions to generate a consecutive task number merging table.

[0057] Its operation relies on a depth-first traversal and logical judgment of the task number mapping matrix. This module integrates a continuity detection unit, which reads the data in the mapping matrix row by row according to the generation order of the task numbers. The detection logic is set as follows: if the channel IDs corresponding to two adjacent task numbers are completely identical, and the time difference between the arrival timestamp of the latter task and the end timestamp of the former task (the theoretical end time estimated by the number of instructions) is less than a preset merging judgment time threshold, then the two tasks are determined to be continuous. The consistency judgment logic in the module also checks the task type flag to ensure that only tasks of the same nature (such as both being computationally intensive) are merged. Once the conditions of continuity and consistency are met, the merging processing unit immediately starts, treating these two or more continuous tasks as a "supertask" block. The merging operation specifically includes: retaining the start time of the first task in the sequence as the starting time after merging, retaining the theoretical end time of the last task in the sequence as the ending time after merging, and summing the number of instructions for all tasks in the sequence to obtain the total number of instructions after merging. Finally, the module stores the merged new number (usually reusing the first task number and adding a merge identifier), the merged start and end times, and the total number of instructions into the consecutive task number merging table.

[0058] Continuing with the previous example, in the task number mapping matrix, task A (channel 1, 500 entries) and task B (channel 1, 1200 entries) are located in the same channel. The system presets a merging decision time threshold of 10 microseconds. Assuming task A processes 100 instructions per microsecond, its theoretical processing time is 5 microseconds, meaning its theoretical end time is 1000 + 5 = 1005 microseconds. At this point, task B arrives at exactly 1005 microseconds, the time difference between the two is 0, less than the 10-microsecond threshold, and their channel IDs are identical, thus satisfying the merging condition. The merging processing unit performs the following operations: the start time after merging is locked at 1000 microseconds; the processing time for Task B is 12 microseconds (1200 instructions divided by 100 instructions / microsecond), therefore the theoretical end time for Task B is 1005 plus 12 equals 1017 microseconds, and the end time after merging is also 1017 microseconds; the total number of instructions is calculated as 500 plus 1200 equals 1700. Task C, being located in channel 2, does not participate in this merging. The final generated continuous task number merging table records one merging item: "01-001_M, Start: 1000, End: 1017, Total Instructions: 1700".

[0059] The load distribution generation submodule calls the number range and total number of instructions in the continuous task number merging table, calculates the processing intensity of the channel per unit time, constructs a two-dimensional matrix of task number and channel number, and generates the task load distribution structure.

[0060] This module is primarily responsible for transforming the merged data into a visualized load distribution structure. It calls a continuous task number merging table and uses an intensity calculation unit to quantify the processing intensity of each merging interval. The calculation logic for processing intensity is as follows: the total number of instructions in the merged item is used as the dividend, and the difference between the end time and start time of the merged item is used as the divisor. This division operation yields the instruction throughput requirement per unit time, i.e., the processing intensity. Subsequently, the matrix construction unit establishes a two-dimensional matrix with time slots as the horizontal axis and channel numbers as the vertical axis. The module fills the corresponding channel rows and time interval columns in the two-dimensional matrix with the calculated processing intensity values. If no tasks are executed within a certain time period, zero or a noise floor value is filled in. The task load distribution structure constructed in this process is essentially a heatmap data structure reflecting the distribution of computational pressure for each channel in different time periods, providing an accurate spatiotemporal reference for subsequent current and energy consumption analysis.

[0061] In the example, for the merged task block "01-001_M", the total number of instructions is 1700, and the time span is 1017 minus 1000, which equals 17 microseconds. The intensity calculation unit performs the operation: 1700 divided by 17, resulting in a processing intensity of 100 instructions / microsecond. For task C, the number of instructions is 800. Assuming the processing rate is also 100 instructions / microsecond, the duration is 8 microseconds, and the start and end time is from 1017 to 1025 (assuming it is immediately following the previous task), then its intensity is also 100 instructions / microsecond. In the constructed two-dimensional matrix, within the time interval of 1000 to 1017 microseconds, the row corresponding to channel 1 is filled with the value "100", and the row corresponding to channel 2 is filled with "0"; within the interval of 1017 to 1025 microseconds, channel 1 is filled with "0", and channel 2 is filled with "100". This two-dimensional matrix clearly shows the dynamic transfer process of the load in time and space (channels), as shown in Table 1.

[0062] Table 1 Example of Task Load Distribution Structure

[0063] Time interval (microseconds) Channel 1 load intensity (commands / microseconds) Channel 2 load intensity (commands / microseconds) Merge task number 1000-1017 100 0 01-001_M 1017-1025 0 100 02-001

[0064] The experimental data above shows that by statistically analyzing, numbering, and generating load distribution for task instructions, the system can accurately quantify the load at the microsecond level. Compared with the traditional method of simply counting the number of tasks, this scheme improves the granularity of load assessment by two orders of magnitude and effectively avoids the load balancing distortion problem caused by the varying lengths of tasks.

[0065] Specifically, such as Figure 3 As shown, the current sequence extraction module includes:

[0066] The task sequence parsing submodule obtains the start and end time periods corresponding to the tasks based on the task number sequence recorded in the task load distribution structure, collects the current change records of the nodes during the task number execution time period, marks and classifies the current sampled values ​​according to the task number sequence, and generates a task number current index table.

[0067] First, the task load distribution structure generated in the preceding steps is loaded, and memory mapping technology is used to quickly locate the task execution time axis of each channel. The parsing unit precisely locks the physical start and end times corresponding to each task number based on the non-zero load intervals on the time axis. Then, the module activates the current sensors (such as high-precision Hall sensors or shunts) deployed at the power input terminals of each computing node. This acquisition system is configured with high-frequency sampling parameters, for example, setting the sampling frequency to 10 kHz, meaning one current sample point is acquired every 100 microseconds. During the execution period corresponding to the task number, the module continuously reads the analog signals from the sensors and converts them into digital current values ​​via an analog-to-digital converter (ADC). To ensure data order, the module tags each acquired current sample with a task number. Specifically, the module creates an array of structures containing "task number," "sampling timestamp," and "current value." When the system clock is within the start and end range of a task, all data acquired via the ADC is automatically associated with that task number. Finally, this tagged data is categorized and stored, generating a task number current index table. This table uses the task number as the primary key and carries all original current sampling points throughout the entire lifecycle of the task.

[0068] Taking specific data as an example, the system parses the execution period of task "01-001_M" as 1000 microseconds to 1017 microseconds. The current sensor is set to a sampling interval of 1 microsecond (i.e., a 1 MHz sampling rate, adjusted for ease of demonstration). At 1000 microseconds, the sensor collects a current value of 1.2 amperes; at 1001 microseconds, it collects 1.25 amperes; and so on, up to 1017 microseconds. The parsing submodule marks these data one by one: data point 1 is {ID:01-001_M, Time:1000, Current:1.2A}, data point 2 is {ID:01-001_M, Time:1001, Current:1.25A}. If a total of 18 points are collected during the task execution, the set of these 18 points constitutes the record item of the task in the index table.

[0069] The current recording splicing submodule determines the continuity of timestamps based on multiple continuous current records associated with the same task number in the task number current index table, and splices the first and last current sampling sequences that meet the continuity conditions to generate a set of numbered continuous current sequences.

[0070] The module iterates through the task number current index table and performs timestamp continuity analysis on multiple current records under the same task number. The determination logic is as follows: The timestamp of the last sampling point of the current record segment is read and the difference is calculated with the timestamp of the first sampling point of the next record segment. If the difference is equal to the sampling interval (or within the allowable jitter error range, such as within 1.5 times the sampling interval), it is determined to be physically continuous, and the beginning and end are directly copied and concatenated in memory. If the difference is greater than the allowable range, it indicates the existence of idle or interrupted periods outside the execution of this task, and the module will perform interpolation completion or segmentation marking strategies. Normally, for sequences that meet the continuity condition, the module will remove redundant header or tail check bits and directly merge the data payloads to form a complete set of numbered continuous current sequences reflecting the complete execution process of the task.

[0071] Continuing the previous example, suppose the current record for task "01-001_M" is interrupted by a brief high-priority interrupt, dividing it into two segments: the first segment is from 1000 to 1008 microseconds, and the second segment is from 1010 to 1017 microseconds. A missing 1009 microseconds of data is present. The splicing submodule calculates that 1010 minus 1008 equals 2 microseconds, while the sampling interval is 1 microsecond, resulting in a difference greater than one times the sampling interval. At this point, the module detects that the gap is extremely short and belongs to the same task context, so it uses linear interpolation to complete the 1009 microseconds of data. Assuming the current at 1008 microseconds is 1.3A and the current at 1010 microseconds is 1.32A, the filler value for 1009 microseconds is calculated as (1.3 + 1.32) divided by 2, which equals 1.31A. After completion, the module merges the two data segments and the filler point to generate a continuous sequence containing complete data from 1000 to 1017 microseconds.

[0072] The sequence alignment generation submodule calls the continuous current sequence corresponding to the task number in the numbered continuous current sequence set, performs sequence position calibration and length normalization processing according to the task number order, performs sequence alignment of the differentiated task number current sequences, and generates a node current perturbation sequence.

[0073] The module calls upon a set of numbered continuous current sequences, selecting a standard reference sequence (usually a historical average sequence or a theoretical standard sequence), or, in multi-node comparisons, the sequence of the master node as the benchmark. The alignment process employs a logical variant of the Dynamic Time Warping (DTW) algorithm. First, the module performs Z-score normalization on each current sequence, calculating the sequence mean and standard deviation, subtracting the mean from each sample point and dividing by the standard deviation to eliminate DC bias and gain differences. Then, the module compares the positions of the sequence to be aligned with the benchmark sequence at feature points (such as peaks and troughs). Based on the task number order, the module stretches or compresses the sequences (through resampling) to align key feature points on the time axis. For example, if a node's execution frequency is slightly slower, its current waveform is compressed to match the standard length; if it's slightly faster, interpolation stretching is performed. The sequence after length warping and feature alignment is defined as the node current perturbation sequence, which eliminates clock drift effects and purely reflects the current fluctuation characteristics caused by task load.

[0074] In the example, the baseline sequence is assumed to be 20 points long, while the sequence "01-001_M" collected by node A, after splicing, is 18 points long. The module first calculates the mean of the node A sequence as 1.25 amperes and the standard deviation as 0.05 amperes. For the first point of 1.2 amperes, the standardization is (1.2 - 1.25) divided by 0.05, resulting in -1.0. After standardizing all points, the module identifies that the node A sequence needs to be stretched to 20 points to match the baseline. The module calculates the stretching ratio as 20 divided by 18, which equals 1.11. Using a linear interpolation algorithm, new calculated values ​​are inserted between the 9th and 10th points, and between the 14th and 15th points, bringing the total length to 20, thus generating the final node current perturbation sequence. As shown in Table 2, this sequence demonstrates consistency across node comparisons.

[0075] Table 2 Data table of current sequence processing process

[0076] step Example of parameters before processing Processing operation logic Example of processed results Data collection and analysis Original analog signal 1MHz sampling, ADC conversion {1000us, 1.2A}, {1001us, 1.25A}... splicing and completion {1008us, 1.3A}, Gap, {1010us, 1.32A} Linear interpolation: (Start + End) / 2 Completion point {1009us, 1.31A} Sequence alignment Length 18 points, mean 1.25A Z-score normalization & resampling stretching A normalized value sequence of length 20 points {-1.0, -0.5...}

[0077] Experimental results show that, after the above sequence extraction and alignment processing, the similarity of current waveforms for the same task between different computing nodes (measured by Pearson correlation coefficient) increased from the original 0.82 to 0.98, which greatly reduced the misjudgment rate caused by hardware differences.

[0078] Specifically, such as Figure 4 As shown, the state transition recognition module includes:

[0079] The current difference calculation submodule extracts the first and last values ​​of adjacent numbered tasks based on the current segments corresponding to the task numbers in the node current disturbance sequence, calculates the difference between the first and last segments, records the difference list in the order of task numbers, and generates a current difference vector between tasks.

[0080] The module focuses on capturing abrupt changes in current waveforms, as these changes often correspond to substantial switching or state changes in computational tasks. It reads the current data segment corresponding to each task number in the node current disturbance sequence one by one. For each independent task segment, the module extracts the first sampled value (denoted as the first value) and the last sampled value (denoted as the last value) of its sequence. Next, the module performs a cross-task difference operation: selecting the first value of the current task number (denoted as NN), subtracting the last value of the preceding task number (denoted as N−1), yields the "first-to-last difference." This process aims to quantify the magnitude of the current jump at the moment of task switching. Following the natural order of task execution, the module sequentially stores these calculated differences into an ordered list, ultimately generating a high-dimensional inter-task current difference vector. Each element in this vector represents the degree of electrical characteristic difference between two adjacent tasks at the transition point.

[0081] For example, suppose the current segment of task A ends with a value of 1.5 amperes (normalized), and the current segment of the following task B begins with a value of 0.8 amperes. The submodule performs a subtraction operation: 0.8 minus 1.5, resulting in -0.7. This value -0.7 is recorded at the corresponding position in the difference vector. If the subsequent task C begins with a value of 2.0 amperes, and the current segment of task B ends with a value of 0.9 amperes, then the difference at the next position is 2.0 minus 0.9, which equals 1.1. The final generated vector is in the form [-0.7, 1.1, ...].

[0082] The task interval matching submodule calls the difference value corresponding to the number in the inter-task current difference vector, and combines it with the start and end positions of the continuous intervals of the same task number in the task load distribution structure to perform interval cross-location of the numbers with concentrated differences, obtain the distribution characteristics of the number intervals, and generate a task number interval mapping table.

[0083] Using the generated difference vector, combined with the previously generated task load distribution structure, spatiotemporal localization is performed. This module sets a difference sensitivity threshold to filter significant current changes. The module iterates through each value in the difference vector, comparing its absolute value with the sensitivity threshold. If the absolute value of the difference at a certain location exceeds the threshold, the system determines that a significant state change has occurred at that location. Subsequently, based on the index position of this difference in the vector, the module looks up the load distribution structure in reverse to find the task number corresponding to that index (e.g., the boundary between task B and task A). The module further extracts the specific start and end times of these tasks on the time axis, thereby determining the specific time window in which the state change occurs. This process maps the abstract current difference back to the specific task execution interval, generating a task number interval mapping table. This table records in detail the task numbers where drastic current fluctuations occur and their corresponding time spans.

[0084] Continuing with the example, the difference sensitivity threshold is set to 0.5. For the aforementioned vector [-0.7, 1.1], the absolute value of the first element, 0.7, is greater than 0.5, and the absolute value of the second element, 1.1, is also greater than 0.5. The module determines that both of these are significant change points. Index 1 corresponds to the boundary between task A and task B, and index 2 corresponds to the boundary between task B and task C. The module queries the load structure and finds that: task A ends at 1017 microseconds, and task B begins at 1017 microseconds; task B ends at 1025 microseconds, and task C begins at 1025 microseconds. The mapping table therefore records: {Mutation point 1: ID_A->ID_B, time: 1017us}, {Mutation point 2: ID_B->ID_C, time: 1025us}.

[0085] The state boundary filtering submodule determines the relationship between the number jump frequency and the interval span based on the number position and current difference distribution in the task number interval mapping table, filters task numbers with concentrated differences and frequent changes across intervals, and generates a set of state switching boundary numbers.

[0086] This module is primarily responsible for extracting the true system state transition boundaries from numerous significant change points. It analyzes the task number interval mapping table, introducing two dimensions—"judgment frequency" and "interval span"—for comprehensive judgment. The module calculates the number of abrupt change points per unit time (i.e., the jump frequency) and the time interval between adjacent abrupt change points (i.e., the interval span). The filtering logic is set as follows: if the jump frequency around a task number is higher than a preset frequency threshold, and its corresponding interval span is lower than a preset stability duration threshold, then the region is considered to be in an unstable transition state and unsuitable as a synchronization anchor point; conversely, if after a jump, the current state remains relatively stable over a long span (i.e., no subsequent frequent jumps), and the jump amplitude is large, then that point is considered a valid state transition boundary. The module extracts all task numbers and their transition points that meet the characteristics of "high difference, low frequency, and long span," forming a set of state transition boundary numbers.

[0087] In this example, task B lasts only 8 microseconds (1017 to 1025), while subsequent task C lasts 500 microseconds without significant fluctuations. The system sets a frequency threshold of 5 transitions every 100 microseconds and a stability threshold of 50 microseconds. After the transition between tasks A and B (1017 microseconds), only 8 microseconds later, another transition between B and C (1025 microseconds) occurs. This indicates that the interval for task B is too short, possibly just a brief pulse interference or a small task, unsuitable as a main state boundary. After the transition between tasks B and C (1025 microseconds), the system does not detect any transitions exceeding the threshold in the subsequent 500 microseconds. Therefore, the module selects the "starting point of task C (i.e., the boundary between tasks B and C)" as a valid state transition boundary, while discarding the boundary between tasks A and B. The final set contains {boundary task ID: C, trigger time: 1025us}.

[0088] Experimental results show that the accuracy of state boundary identification reached 99.2% after adopting this multi-dimensional screening mechanism. Compared with the single threshold judgment method, it effectively eliminated 85% of the false triggering signals caused by transient tasks, ensuring the stability of subsequent synchronization operations.

[0089] Specifically, such as Figure 5 As shown, the synchronous trigger generation module includes:

[0090] The number node matching submodule calls all task numbers in the state switching boundary number set, compares the existence of the same number in the node task execution record, extracts the task numbers that appear repeatedly in all nodes, summarizes them in order of number to form a unified set, and generates a list of node shared numbers.

[0091] The goal is to find "anchor" tasks that can serve as a common reference point across multiple edge computing nodes. The module first reads all candidate task numbers marked as state boundaries from the "state transition boundary number set" generated in the previous steps. Then, the module retrieves the historical task execution records of all participating nodes (e.g., node A, node B, node C) via network communication or shared memory access mechanisms. Sub-modules compare the existence of candidate numbers in the records of each node one by one. The specific logic uses set intersection operations: a baseline set is established, initialized with the boundary number set of the first node, and then the intersection is taken with the number sets of subsequent nodes. A task number is only retained if it is retrieved in the execution records of all participating nodes. The module extracts these task numbers that appear repeatedly across the entire network and arranges them according to their logical order in the original business process, thereby generating a list of shared node numbers. This list represents milestone events common to all nodes and can be used for alignment.

[0092] Taking a three-node system as an example, the boundary set of node A is {Task_10, Task_20, Task_35}, node B is {Task_10, Task_22, Task_35}, and node C is {Task_10, Task_15, Task_35}. The submodule first compares nodes A and B, obtaining the intersection {Task_10, Task_35}; then it compares this intersection with node C, still obtaining {Task_10, Task_35}. At this point, Task_20, Task_22, and Task_15 are removed because they are not shared by all nodes. The final generated list of shared IDs is [Task_10, Task_35].

[0093] The identifier sorting and encoding submodule rearranges the positions of nodes according to the task numbers in the node shared number list and the first appearance time of each node, constructs a unified number sorting structure between nodes, and adds a unified identifier to each group of numbers to generate a synchronization identifier order mapping table.

[0094] The module takes over the processing of the shared list. Although the task numbers are the same, the physical occurrence time of the same task may differ on different nodes due to differences in node startup time or processing speed. The module first iterates through each task number in the shared list, querying its "first occurrence timestamp" within each node. To build a unified sorting structure, the module reconfirms and sorts the tasks on a global timeline based on the average or median of these timestamps (to prevent out-of-order issues caused by clock rollback). After sorting, the module assigns a globally unique "synchronization identifier" (Sync_ID) to each successfully paired task in the list. This identifier is typically an incrementing hexadecimal integer or UUID format, with version control bits appended. The module establishes a one-to-one mapping relationship between the "original task number," the "global synchronization identifier," and the "local sorting index" of each node, generating a synchronization identifier order mapping table. This table not only records "who is the synchronization point" but also defines the "order of synchronization points."

[0095] Continuing the previous example, for the shared task Task_10, node A records the time as T=500ms, node B as T=502ms, and node C as T=498ms. For Task_35, the times are T=1200ms, 1205ms, and 1198ms respectively. The module confirms that Task_10 is generally earlier than Task_35 in terms of time, so the order is correct. The module assigns synchronization identifiers: Task_10 corresponds to Sync_001, and Task_35 corresponds to Sync_002. The generated mapping table contains the entry: {Global_ID:Sync_001, Orig_ID:Task_10, Order_A:5, Order_B:4, Order_C:6} (assuming it is the 5th task on node A, the 4th on node B, and so on).

[0096] The trigger number output submodule calls the unified number sequence corresponding to the synchronous identifier sequence mapping table, integrates the mapping content by node group, extracts the number set after the synchronization calibration is completed, and generates a multi-node synchronous trigger number set.

[0097] The module reads the synchronization identifier sequence mapping table and decomposes and reassembles the mapping content according to the node dimension. Each computing node generates a dedicated synchronization configuration file. In this file, the module extracts the "synchronization trigger number set" that the node needs to focus on. In specific processing, the module calculates the instruction interval or time interval of each synchronization point relative to the previous synchronization point and adjusts the triggering logic accordingly. For example, if it finds that a node has significantly less task load between two synchronization points than other nodes, the module will append "wait" or "idle" instruction markers to the output set to ensure that the state of each node is consistent during synchronization triggering. The final multi-node synchronization trigger number set is actually a set of control data packets containing specific trigger instructions, target task numbers, and expected synchronization times, ready to be sent to the scheduling controllers of each node.

[0098] In the example, for node A, the output submodule generates the following instruction set: [WaitforSync_001 (Task_10) atT~500; WaitforSync_002 (Task_35) atT~1200]. Corresponding instructions are also generated for nodes B and C. Specifically, if the calculation shows that node B's task processing speed between Sync_001 and Sync_002 is too fast, the module will append a "Delay5ms" correction parameter before the Sync_002 trigger instruction for node B. The final data structure is shown in Table 3.

[0099] Table 3 Multi-node Synchronization Trigger Set Structure

[0100] Synchronization identifier Original Task ID Node A triggers action Node B triggers action Node C triggers action Sync_001 Task_10 Execute immediately Execute immediately Execute immediately Sync_002 Task_35 Normal execution Execute after 5ms delay Normal execution

[0101] In actual testing, this synchronization mechanism controlled the coordination error between multiple nodes to within 2 instruction cycles, which is significantly better than the traditional timestamp synchronization method (the error is usually 50-100 instruction cycles), ensuring the accurate alignment of the distributed task flow.

[0102] Specifically, such as Figure 6 As shown, the processing chain building module includes:

[0103] The task order reordering submodule extracts the original execution order of the corresponding tasks on the nodes based on the task numbers recorded in the multi-node synchronization trigger number set, rearranges them according to the number order, establishes a mapping relationship between task numbers and reordering order, and generates a synchronization task order matrix.

[0104] This module aims to solve the problem of local execution disorder caused by parallel processing in distributed environments. It loads the "multi-node synchronization trigger number set" generated in the previous stage, using it as a skeleton to rigidly constrain the execution order. The module extracts the current original task execution queue of each node and identifies all intermediate tasks located between two synchronization trigger numbers. Then, based on the global order of the synchronization trigger numbers (i.e., Sync_001 takes precedence over Sync_002), the module forcibly adjusts the arrangement logic of these intermediate tasks. Specifically, the module constructs a directed acyclic graph (DAG) logical model with synchronization numbers as nodes, mapping intermediate tasks to edges or child nodes in the graph. If a node is found to have originally planned to execute tasks belonging to Sync_002 before tasks belonging to Sync_001 (this may be due to local optimization algorithms), the submodule will forcibly perform a "reordering," moving tasks belonging to the Sync_001 interval forward. The module establishes a key-value pair mapping between "task numbers" and "corrected reordering indexes," generating a synchronization task order matrix. This matrix ensures that, within any given time slice, the task flow of each node is macroscopically aligned and ordered.

[0105] To illustrate with an example, assume the original execution queue of node A is [Task_10 (Sync_001), Task_X, Task_Y, Task_35 (Sync_002), Task_Z]. The system detects that the priority of Task_Z has been temporarily increased by the local scheduler, causing it to be placed before Task_35. The reordering submodule, based on the synchronization set rules (Task_35 is the synchronization point, and subsequent stage tasks can only be processed after it), forcibly moves Task_Z back after Task_35. The generated synchronization task order matrix explicitly specifies: Index_1: Task_10, Index_2: Task_X, Index_3: Task_Y, Index_4: Task_35, Index_5: Task_Z.

[0106] The number binding encoding submodule calls the task rearrangement result in the synchronous task sequence matrix, adds the corresponding sequence identifier code to the number, forms a one-to-one correspondence structure between task number and sequence code, and stores the bound content into the node structure table to generate a task number sequence mapping table.

[0107] The module invokes the synchronization task sequence matrix to generate a composite sequence identifier for each task number in the matrix. This identifier consists of two parts: a "global synchronization segment ID" and an "intra-segment offset." For example, the identifier for the third task located between Sync_001 and Sync_002 might be encoded as "S01_OFF03." This one-to-one binding relationship is written into the node structure table. This step not only reshapes the digital identity of the tasks but also makes the position of each task in the processing chain indexable and verifiable through structured storage. The final generated task number sequence mapping table assigns each task absolute coordinates within the entire edge computing collaborative network.

[0108] In the example, for Task_Y of node A, it is located after Sync_001 and before Sync_002, and is the second task in this interval (Task_X is the first). The module encodes it as "01_02". For Task_35 itself, as a synchronization point, it is encoded as "02_00". These codes are written into the mapping table: {Task_Y:01_02, Task_35:02_00}. This encoding method allows the system to determine that Task_Y must be completed before Task_35 based solely on the encoding, without traversing the entire queue.

[0109] The node concatenation generation submodule concatenates nodes according to the task arrangement and sequence identifier of the nodes in the task number sequence mapping table, concatenates them sequentially according to the physical number of the nodes, establishes a cross-node processing relationship graph, extracts the continuous transfer path of tasks between nodes, and generates a load-aware edge computing collaborative processing task sequence.

[0110] The module establishes logical connections across nodes based on the encoding information in the task number sequence mapping table and the physical topology numbers of each computing node (such as node IP addresses or physical port numbers). Tasks with the same or related sequence identifiers on different nodes are considered adjacent links in a processing chain. By analyzing the data dependencies between tasks (i.e., the output of one node is the input of the next), the module constructs a "cross-node processing relationship graph" in memory. In this graph, nodes represent computing units, and directed edges represent the flow paths of task data. The module uses path search algorithms from graph theory (such as depth-first search or variants of Dijkstra's algorithm) to extract one or more continuous transfer paths from the source node to the sink node. This path comprehensively considers node load (from the load distribution module) and synchronization constraints, ultimately generating a load-aware edge computing collaborative processing task sequence.

[0111] Specifically, assume the system has node A (preprocessing) and node B (deep analysis). The mapping table shows that the data generated by Task_Y (encoded 01_02) of node A needs to be passed to node B. The submodule establishes a connection from A to B in the relationship graph. If the path search finds that node B is overloaded during the 01_02 period (based on the load distribution structure), the module may insert a "buffer / wait" node in the sequence, or find an alternative path (such as forwarding via an idle node C). Assuming that node B has normal load, the final sequence instruction generated by the system is: [NodeA executeTask_Y->TransferDatatoNodeB->NodeB executeTask_Dependent_on_Y]. This sequence ensures dual connectivity of data flow and control flow at both the physical and logical levels.

[0112] Experimental data shows that the collaborative sequence generated by this processing chain building module reduces the average transfer latency of tasks between edge nodes by 35%, and the retransmission rate caused by out-of-order delivery decreases from 12% to 0.5%, which greatly improves the overall throughput and stability of the edge computing system.

[0113] The above description is merely a specific embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the technical scope disclosed in the present invention should be included within the scope of protection of the present invention. Therefore, the scope of protection of the present invention should be determined by the scope of protection of the technical solution.

Claims

1. A load-aware edge computing node collaborative processing system, characterized in that, The system includes: The task density construction module analyzes the number of instructions and arrival order of tasks in the task queue, numbers them according to the node processing channel allocation rules, establishes the correspondence between task number and the number of instructions and the arrival order, merges adjacent numbered tasks that arrive consecutively, and constructs a task load distribution structure. The current sequence extraction module collects the node current change records corresponding to the task number in the task load distribution structure, splices the continuous current records of the same task number, aligns the sequence according to the task number, and generates a node current perturbation sequence. The state transition identification module compares the differences between the beginning and end of the current segments corresponding to adjacent task numbers in the node current disturbance sequence, and combines the continuous interval of the task number in the task load distribution structure to filter the task numbers where the differences occur, and generates a set of state transition boundary numbers. The synchronization trigger generation module calls all task numbers in the state switching boundary number set, compares the synchronization occurrence of the task numbers in the nodes, writes a unified identifier and sorts the order to generate a multi-node synchronization trigger number set. The processing chain construction module rearranges the execution order of corresponding tasks according to the set of multi-node synchronous trigger numbers, binds the rearranged task order with the number identifier, and connects them in series according to the execution order of the nodes to construct a load-aware edge computing collaborative processing task sequence. The synchronous occurrence of the task number in the comparison node refers to comparing the positions of the same task number appearing simultaneously in the current disturbance sequence in the node to determine the synchronous triggering characteristics.

2. The load-aware edge computing node collaborative processing system according to claim 1, characterized in that: The task load distribution structure includes a mapping relationship between task number and instruction quantity, a mapping relationship between task number and arrival order, and a number merging identifier for consecutive tasks. The node current disturbance sequence includes a continuous current segment splicing result, a task number alignment sequence, and a current disturbance time period identifier. The state switching boundary number set includes the corresponding number for the difference between the first and last currents, the numbering duration interval filtering result, and the number identifier for current mutation concentration. The multi-node synchronous trigger number set includes a number consistency identifier between nodes, a unified number identifier sequence, and a numbering order arrangement structure. The load-aware edge computing collaborative processing task sequence includes the rearranged task execution order, the number and identifier binding structure, and the serial execution path between nodes.

3. The load-aware edge computing node collaborative processing system according to claim 1, characterized in that: The task number for which the difference appears is selected by identifying the task number with the change in current based on the difference between the beginning and end of adjacent task number segments in the current disturbance sequence, combined with the duration of the task number in the task load distribution structure.

4. The load-aware edge computing node collaborative processing system according to claim 1, characterized in that, The task density construction module includes: The task instruction statistics submodule extracts the timestamp and instruction count based on the arrival order of tasks and the corresponding number of instructions in the task queue, calls the channel allocation rules to assign numbers to tasks, and generates a task number mapping matrix. The task number merging submodule detects consecutively numbered tasks and judges channel consistency based on the number and arrival order in the task number mapping matrix, and merges the task numbers that meet the conditions to generate a consecutive task number merging table. The load distribution generation submodule calls the number range and total number of instructions in the continuous task number merging table, calculates the processing intensity of the channel per unit time, constructs a two-dimensional matrix of task number and channel number, and generates the task load distribution structure.

5. The load-aware edge computing node collaborative processing system according to claim 1, characterized in that, The current sequence extraction module includes: The task sequence parsing submodule obtains the start and end time periods corresponding to the tasks based on the task number sequence recorded in the task load distribution structure, collects the current change records of the nodes during the task number execution time period, marks and classifies the current sampled values ​​according to the task number sequence, and generates a task number current index table. The current recording splicing submodule determines the continuity of timestamps based on multiple continuous current records associated with the same task number in the task number current index table, and splices the first and last current sampling sequences that meet the continuity conditions to generate a set of numbered continuous current sequences. The sequence alignment generation submodule calls the continuous current sequence corresponding to the task number in the numbered continuous current sequence set, performs sequence position calibration and length normalization processing according to the task number order, performs sequence alignment of the differentiated task number current sequences, and generates the node current perturbation sequence.

6. The load-aware edge computing node collaborative processing system according to claim 1, characterized in that, The state transition recognition module includes: The current difference calculation submodule extracts the first and last values ​​of adjacent numbered tasks based on the current segments corresponding to the task numbers in the node current disturbance sequence, calculates the difference between the first and last segments, records the difference list in the order of task numbers, and generates a current difference vector between tasks. The task interval matching submodule calls the difference value corresponding to the number in the inter-task current difference vector, and combines it with the start and end positions of the continuous intervals of the same task number in the task load distribution structure to perform interval cross-location of the numbers with concentrated differences, obtain the distribution characteristics of the number intervals, and generate a task number interval mapping table. The state boundary filtering submodule determines the relationship between the number jump frequency and the interval span based on the number position and current difference distribution in the task number interval mapping table, filters task numbers with concentrated differences and frequent changes across intervals, and generates a set of state switching boundary numbers.

7. The load-aware edge computing node collaborative processing system according to claim 1, characterized in that, The synchronization trigger generation module includes: The number node matching submodule calls all task numbers in the state switching boundary number set, compares the existence of the same number in the node task execution record, extracts the task numbers that appear repeatedly in all nodes, summarizes them in order of number to form a unified set, and generates a list of node shared numbers. The identifier sorting and encoding submodule rearranges the positions of nodes according to the task numbers in the node shared number list and the first appearance time of each node, constructs a unified number sorting structure between nodes, and adds a unified identifier to each group of numbers to generate a synchronization identifier order mapping table. The trigger number output submodule calls the unified number sequence corresponding to the synchronization identifier sequence mapping table, integrates the mapping content by node group, extracts the number set after synchronization calibration, and generates a multi-node synchronization trigger number set.

8. The load-aware edge computing node collaborative processing system according to claim 1, characterized in that, The processing chain construction module includes: The task order reordering submodule extracts the original execution order of the corresponding tasks on the nodes based on the task numbers recorded in the multi-node synchronization trigger number set, rearranges them according to the number order, establishes a mapping relationship between task numbers and reordering order, and generates a synchronization task order matrix. The number binding encoding submodule calls the task rearrangement result in the synchronous task sequence matrix, adds the corresponding sequence identifier code to the number, forms a one-to-one correspondence structure between task number and sequence code, and stores the bound content into the node structure table to generate a task number sequence mapping table. The node concatenation generation submodule concatenates nodes according to the task arrangement and sequence identifier of the nodes in the task number sequence mapping table, establishes a cross-node processing relationship graph, extracts the continuous transfer path of tasks between nodes, and generates a load-aware edge computing collaborative processing task sequence.

9. The load-aware edge computing node collaborative processing system according to claim 8, characterized in that: The continuous transfer path of tasks between nodes refers to the processing path formed by connecting tasks in the execution order on differentiated nodes according to the task number order mapping table, so that tasks flow sequentially between nodes.

Images