Multi-device cooperative control method applied to embedded real-time operating system deployment

Abstract

The application discloses a multi-device cooperative control method applied to embedded real-time operating system deployment and relates to the field of embedded real-time operating systems, and comprises the following steps: S1: constructing a real-time dependency graph of a task link, and decomposing a multi-device cooperative task into a sub-task link unit containing an execution path, a real-time constraint threshold and a cross-device communication dependency relationship. The multi-device cooperative control method applied to embedded real-time operating system deployment effectively solves the problems of task priority conflict and resource utilization imbalance in a multi-device heterogeneous environment through a dynamic priority transfer mechanism and a distributed resource elasticity perception model. The system can perceive device load, communication link stability and task real-time requirement in real time, dynamically adjust sub-task weight and an execution path, ensure conflict-free transmission of end-to-end delay constraints, optimize global resource utilization rate and avoid the problems of device overload or idling caused by traditional static scheduling.

Description

TECHNICAL FIELD

[0001] The present application relates to the field of embedded real-time operating systems, in particular to a multi-device collaborative control method applied to embedded real-time operating system deployment. BACKGROUND

[0002] As a core supporting technology in the fields of industrial automation, intelligent Internet of Things, etc., embedded real-time operating systems are gradually evolving towards multi-device collaborative control. Traditional multi-device collaborative solutions are usually based on pre-set static task priority and fixed resource allocation mode, which can meet the basic real-time requirements in scenarios where the device type is single and the task demand is stable. However, with the diversification of industrial site devices and the continuous improvement of task complexity, the heterogeneous characteristics among devices are increasingly prominent, and devices with different computing power, communication interfaces and real-time levels coexist in the same system, leading to the gradual exposure of the limitations of traditional collaborative control methods. Existing technologies often use local optimization scheduling strategies, i.e. implementing priority management within a single device or a group of homogeneous devices, lacking a global coordination mechanism across devices. This fragmented scheduling mode is prone to cause task execution conflicts among multiple devices, such as high-priority tasks missing the deadline due to cross-device communication delay, or low-load devices being idle due to the inability to perceive the global resource state. At the same time, task demand fluctuations and device state changes in dynamic environments further exacerbate the uncertainty of the system, making it difficult for fixed priority allocation mechanisms to adapt to the dynamic adjustment needs of real-time constraints. Some solutions attempt to alleviate the contradiction by increasing redundant resources or improving the performance of a single device, but such methods not only cause resource waste, but also fail to fundamentally solve the real-time transmission and resource coordination problems in multi-device collaboration. Existing technologies still have significant defects in achieving global optimization of task priority and real-time constraint collaborative scheduling in a dynamic heterogeneous multi-device environment. SUMMARY

[0003] (I) Technical problems solved

[0004] In view of the deficiencies of the prior art, the present application provides a multi-device collaborative control method applied to embedded real-time operating system deployment, which solves the problem of how to construct a globally adaptive collaborative scheduling mechanism in a complex environment where device heterogeneity, task dynamics and resource distribution are intertwined, ensuring conflict-free transmission of real-time constraints and efficient use of resources in multi-device task links.

[0005] (II) Technical solutions

[0006] To achieve the above purpose, the present application is implemented by the following technical solutions: a multi-device collaborative control method applied to embedded real-time operating system deployment, comprising the following steps:

[0007] S1: Construct a real-time dependency graph of task link, and decompose the multi-device collaborative task into sub-task link units containing execution path, real-time constraint threshold, and cross-device communication dependency;

[0008] S2: Dynamically calculate the priority weight of each sub-task according to the end-to-end delay requirement of the sub-task link unit, the device load state, and the communication link stability;

[0009] S3: Real-time collection of heterogeneous device computing power, memory, and communication bandwidth data through distributed resource probes, generation of resource adaptation strategy templates, decomposition of tasks into lightweight execution units adapted to different device capabilities, and dynamic allocation to low-load devices;

[0010] S4: Embed delay prediction and compensation agents in key nodes of the task link, predict end-to-end delay fluctuations based on historical delay data and device state, and dynamically select redundant execution copies or low-load path switching strategies;

[0011] S5: Verify the real-time constraint achievement rate of the global scheduling model through offline simulation, and verify the feasibility of resource migration paths and the additional resource overhead of compensation strategies through online dynamic sandbox.

[0012] In constructing the real-time dependency graph of the task link, the system decomposes the task into sub-task link units with clear input-output relationship according to the data flow and logical execution order in multi-device collaborative task. Each sub-task unit needs to define its execution path, real-time constraint threshold, and cross-device communication dependency. The planning of the execution path needs to combine with the device function mapping relationship, for example, in the industrial control scene, the sensor data acquisition sub-task needs to be bound to the device with specific interface protocol, the control algorithm operation sub-task needs to be allocated to the high-performance device, and the actuator driving sub-task needs to be deployed to the low-delay communication device. The real-time constraint threshold is split according to the end-to-end delay requirement of the task link, for example, the total delay threshold is decomposed into stage completion time limit according to the execution order of sub-tasks, and is dynamically adjusted with the device state. The establishment of cross-device communication dependency needs to analyze the interface compatibility between sub-tasks, for example, when a sub-task needs to transmit data through a wireless communication module, the protocol parsing ability and signal coverage strength of the receiving device need to be checked, if the protocol does not match or the signal strength is insufficient, the backup communication path is automatically selected and the dependency relationship is updated.

[0013] Preferably, the dynamic calculation of the priority weight of each sub-task includes:

[0014] Based on the real-time decay factor and the resource occupation feedback coefficient, a priority weight calculation model of the sub-task link is established;

[0015] When detecting that a sub-task cannot meet the priority due to device load or communication delay, a priority compensation request is sent to the associated device through a two-way priority negotiation mechanism;

[0016] The device receiving the request adaptively adjusts the priority weight and execution timing of the local sub-task according to the current resource state and the global demand of the task link.

[0017] When dynamically calculating the priority weight of the sub-task, the system collects the load state of the target device, the communication link stability parameters and the real-time constraint threshold of the sub-task in real time, and generates a dynamic weight value through a priority weight calculation model. The evaluation of the device load state includes the computing power occupancy rate, the memory usage rate and the task queue length. For example, when the computing power occupancy rate of a device is continuously higher than the safety threshold, the priority weight of the associated sub-task is attenuated according to the preset rule. The communication link stability parameters are calculated by combining the historical transmission success rate and the real-time signal quality. For example, for a wireless communication path, if the signal strength is lower than the acceptable range and the packet loss rate rises, an attenuation coefficient is applied to the sub-task weight that depends on the path. The dynamic adjustment of the real-time constraint threshold is based on the remaining time margin of the task link. For example, when a sub-task has insufficient remaining time due to upstream delay, the system proportionally increases its priority weight to speed up execution.

[0018] Preferably, the generation of the real-time attenuation factor includes:

[0019] According to the end-to-end delay requirement of the task link and the stability parameters of the device communication interface, the priority attenuation value of the sub-task during cross-device transmission is calculated;

[0020] When the priority attenuation value exceeds the preset threshold, a priority compensation request is triggered and broadcast to the associated device.

[0021] Preferably, the execution of the two-way priority negotiation mechanism includes:

[0022] The device receiving the priority compensation request reassigns the priority weight of the local task based on the real-time data of the resource elasticity perception matrix;

[0023] The adjusted priority weight is fed back to the global scheduling module of the task link, and the execution timing of the sub-task link is updated.

[0024] Preferably, the generation of the resource adaptation strategy template includes:

[0025] The computing power, memory and communication bandwidth of the heterogeneous devices are abstracted into a virtual resource pool that can be dynamically mapped;

[0026] Through a resource load balancing gradient algorithm, the lightweight execution unit is dynamically allocated according to the real-time load state of the device, and real-time loss evaluation parameters of the resource migration path are generated.

[0027] In generating the resource adaptation strategy template, the system abstracts the resource capabilities of heterogeneous devices into dynamically mappable virtual resource pools, and collects device state data in real time through distributed resource probes. The resource probe module periodically monitors the computational power margin, memory free blocks, and communication bandwidth availability of the device, and aggregates the data to the resource adaptation engine. The engine generates adaptation strategies according to the resource demand characteristics of the task units, such as matching high-computational-power devices for computationally intensive tasks and allocating high-bandwidth links for communication-intensive tasks; wherein the resource demand characteristics include computationally intensive, memory sensitive, or communication intensive. During dynamic allocation, the system compares the device resource state and task demand in real time, and if the resource margin of the target device is lower than the safety threshold of the task demand, it triggers task migration or secondary decomposition. For example, when a high-computational-power device cannot handle computationally intensive tasks due to sudden load, the system splits it into multiple micro-task units and allocates them to multiple low-load devices for parallel execution, while adjusting the real-time threshold of each micro-task to match the execution logic after decomposition.

[0028] Preferably, the real-time loss evaluation parameter of the resource migration path is used for:

[0029] When the device resource state mutates, the execution of the unfinished task unit is interrupted;

[0030] The priority weight is recalculated according to the real-time loss evaluation parameter, and the mapping relationship of the virtual resource pool is updated after the task unit is migrated to the target device.

[0031] Preferably, the execution of the delay prediction and compensation agent includes:

[0032] Redundant execution copies are pre-embedded at the communication nodes of the task link, and the end-to-end delay fluctuation range is predicted based on the device state;

[0033] If the predicted delay exceeds the real-time constraint threshold, start the redundant copy or switch to the low-load path, and select the compensation strategy with the minimum resource overhead through the path switching cost evaluation function.

[0034] The delay prediction and compensation agent is deployed at the key nodes of the task link. By analyzing historical delay data and real-time device status, the agent predicts the end-to-end delay fluctuation and triggers compensation strategies. When the agent detects a delay risk, it selects the optimal compensation scheme according to the path switching cost evaluation function: if the main path communication quality deteriorates but the backup path resources are sufficient, it generates redundant execution copies and transmits them in parallel; if the backup path load is significantly lower than the main path, it directly switches the execution path and adjusts the priority of subsequent sub-tasks. For example, at the instruction transmission node from the controller to the actuator, if the main path delay prediction exceeds the threshold, the agent immediately enables the backup path and increases the priority weight of the task on this path to ensure that the instructions are delivered on time. For sudden communication interruption scenarios, the agent rolls back to the latest available state based on the device health snapshot and reconstructs the task link topology, such as migrating the tasks of the interrupted node to redundant devices, while compressing the execution window of downstream sub-tasks to compensate for the migration time.

[0035] Preferably, the offline simulation verification includes:

[0036] Random task requests and device fault disturbances are injected into the virtualized heterogeneous device cluster to statistically evaluate the real-time constraint achievement rate of the global scheduling model.

[0037] According to the simulation results, the decay factor threshold in the priority weight calculation model and the allocation parameters of the resource load balancing gradient algorithm are dynamically modified.

[0038] In the offline simulation verification phase, the system constructs a virtualized heterogeneous device cluster, simulates task requests and device disturbances in real scenarios, and verifies the real-time constraint achievement rate and robustness of the global scheduling model. Random task streams and device fault events are injected during the simulation process, such as periodically generating high real-time control instructions to simulate sudden load surges or communication link interruptions. The system records the end-to-end delay data of each sub-task and calculates the achievement rate. If the achievement rate of a certain device group is consistently below the preset standard, the priority decay factor and resource allocation weight are dynamically adjusted. For example, when the achievement rate of low-power devices is insufficient, the task allocation density is reduced and the priority compensation value of the redundant path is increased. For priority conflicts exposed in the simulation, the system simulates local optimization strategies in a sandbox, such as splitting tasks that compete for resources or introducing asynchronous execution windows, and iteratively optimizes scheduling parameters.

[0039] Preferably, the online dynamic sandbox verification includes:

[0040] The execution fragment of the task link in the real scenario is intercepted to simulate the switching process of the resource migration path.

[0041] The sandbox verification filters whether the additional resource overhead of the compensation strategy is below the preset threshold and feeds back to the global scheduling module for strategy iterative optimization.

[0042] In the online dynamic sandbox verification stage, the system intercepts the task link fragment in the real scene, reproduces the resource state and real-time constraint, and injects controllable abnormal events to verify the effectiveness of the compensation strategy. For example, in the mechanical arm control link, simulate the memory depletion of a certain controller, trigger the resource migration and task decomposition process. The sandbox real-time monitors the feasibility of the migration path and the resource overhead of the compensation strategy, if the migration delay exceeds the remaining time margin of the subtask or the resource consumption exceeds the safety threshold, the alternative solution is started. For example, when direct migration is not feasible, the task is split into microtask units and assigned to multiple devices, or the task execution precision is reduced to compress the resource demand. The verification result is fed back to the global scheduling module, dynamically updating the strategy template and calculation rules, such as disabling high-overhead migration paths or optimizing the generation timing of redundant copies, ultimately improving the adaptive ability of the system in a dynamic heterogeneous environment.

[0043] A multi-device collaborative control system applied to embedded real-time operating system deployment, comprising:

[0044] A task link analysis module for constructing a real-time dependency graph and decomposing subtask link units;

[0045] A dynamic priority scheduling module for executing a priority weight calculation model and a bidirectional priority negotiation mechanism;

[0046] A resource elasticity adaptation module for managing virtual resource pools and generating resource adaptation strategy templates;

[0047] A real-time compensation module for deploying delay prediction agents and path switching strategies;

[0048] A verification engine module for performing offline simulation and online dynamic sandbox dual verification.

[0049] (Three) beneficial effects

[0050] The present application provides a multi-device collaborative control method applied to embedded real-time operating system deployment. It has the following beneficial effects:

[0051] (I) The multi-device collaborative control method applied to embedded real-time operating system deployment effectively solves the problems of task priority conflict and resource utilization imbalance in a multi-device heterogeneous environment through a dynamic priority transfer mechanism and a distributed resource elasticity perception model. The system can real-time perceive device load, communication link stability and task real-time requirement, dynamically adjust subtask weight and execution path, ensure conflict-free transmission of end-to-end delay constraint, optimize global resource utilization, and avoid device overload or idle problem caused by traditional static scheduling.

[0052] (ii) The multi-device collaborative control method applied to the deployment of an embedded real-time operating system improves the robustness and adaptability of the system in dynamic disturbance scenarios by combining a cross-device real-time compensation algorithm and a dual verification mechanism. Through strategies such as redundant copy pre-embedding, path dynamic switching, and task unit secondary decomposition, the system can quickly respond to device failures or resource mutations, ensuring the real-time performance of the core link. The dual verification framework of offline simulation and online sandbox ensures the reliable landing of scheduling strategies in complex environments, thereby achieving high-reliability, low-latency multi-device collaborative control in industrial automation, smart Internet of Things, and other fields. BRIEF DESCRIPTION OF DRAWINGS

[0053] Figure 1 The figure is a schematic diagram of the overall framework of the application.

[0054] Figure 2 The figure is a control logic timing diagram of the application. DETAILED DESCRIPTION

[0055] The technical solutions in the embodiments of the application will be described in detail below with reference to the accompanying drawings. Obviously, the described embodiments are only a part of the embodiments of the application, not all embodiments. Based on the embodiments in the application, all other embodiments obtained by those skilled in the art without creative labor are within the scope of protection of the application.

[0056] Please refer to Figure 1 and Figure 2 The application provides a technical solution: a multi-device collaborative control method applied to the deployment of an embedded real-time operating system, including the following steps:

[0057] S1: Construct a real-time dependency graph of task links, and decompose the multi-device collaborative task into sub-task link units containing execution paths, real-time constraint thresholds, and cross-device communication dependencies. When constructing the real-time dependency graph of task links, first analyze the end-to-end real-time requirements of the task links according to the logical execution order and data flow of the multi-device collaborative task, and decompose the task into sub-task link units with clear input-output relationships.

[0058] Specifically, it includes: based on the task type and device function mapping relationship, the logical dependency level between sub-tasks is identified, for example, in the industrial automation scene, the sensor data acquisition, control algorithm calculation, actuator action trigger and other links are divided into independent sub-tasks, and the latest completion time threshold of each sub-task is marked; According to the device heterogeneous characteristics, the cross-device communication dependency relationship is established, for example, if a sub-task needs to forward data through a specific device, mark the communication interface type and transmission stability parameters in its execution path; At the same time, the device state change is dynamically monitored, and when it is detected that the sub-task cannot be executed in the original path, the alternative execution path is automatically generated and the real-time constraint threshold is recalculated; The device heterogeneous characteristics include computing power difference and communication protocol compatibility; The device state change includes sudden load surge or communication link interruption. For example, when a sub-task causes communication delay to exceed the limit due to overload of the target device, the system will select the migration path according to the resource idle state of the standby device and the communication interface matching degree, and update the real-time threshold of the sub-task, to ensure that the end-to-end delay of the task link still meets the global demand.

[0059] In addition, the division rationality of the sub-task link unit is verified by sandbox simulation, and if logical dependency conflicts or real-time threshold allocation imbalance are found, the sub-task granularity or dependency relationship is adjusted, and finally the task link topology structure that can dynamically adapt to the state of heterogeneous devices is generated.

[0060] S2: According to the end-to-end delay requirement of the sub-task link unit, the device load state and the communication link stability, the priority weight of each sub-task is dynamically calculated; In the process of dynamically calculating the priority weight of the sub-task, the system first collects the end-to-end delay requirement of the sub-task link unit, the current load state of the target device and the stability parameters of the communication link in real time. For the end-to-end delay requirement, according to the global real-time constraint of the task link, the latest completion time threshold of the sub-task is decomposed into delay allocation values of each stage according to the execution path, for example, if the total delay threshold is 100ms and the sub-task link contains three stages, then the stage delay values are dynamically allocated according to the execution order, such as 30ms, 40ms, 30ms, and the allocation proportion is adjusted in real time according to the device load fluctuation.

[0061] When it is detected that the current load of a device exceeds a preset threshold, such as CPU usage higher than 80%, the priority weight of the sub-task to be executed on the device is downgraded, and a load warning signal is sent to the associated device; If the communication link stability parameters, such as packet loss rate or delay jitter, exceed the acceptable range, the priority weight of the sub-task dependent on the link is attenuated, for example, the priority weight is reduced by 10% for every 5% increase in packet loss rate.

[0062] For sub-tasks with multiple path options, the system calculates the priority weight candidate values of each path in parallel, and selects the path with the most stable communication link that meets the real-time constraints as the execution scheme. When a sub-task cannot be executed on the original path due to sudden device failure or communication interruption, the priority weight recalculation process is triggered immediately: based on the device load, communication stability, and remaining delay margin of the backup path, the priority weight is redistributed and broadcast to the associated devices to ensure that the end-to-end delay requirements of the task link are not violated. In addition, the effectiveness of the priority weight adjustment strategy is verified through sandbox simulation. If the weight distribution leads to device resource contention or real-time conflicts, the system backtracks to the last stable state and uses a gradual weight correction algorithm to recalculate.

[0063] S3: Real-time collection of heterogeneous device computing power, memory, and communication bandwidth data through distributed resource probes, generation of resource adaptation strategy templates, decomposition of tasks into lightweight execution units adapted to different device capabilities and dynamic allocation to low-load devices; while implementing distributed resource probe collection and task dynamic allocation, the system periodically collects real-time computing power utilization, available memory capacity, and communication bandwidth remaining of the target device through the lightweight resource probe module deployed on each device, and aggregates the data to the global resource adaptation engine. For example, for computing power collection, the probe module estimates the current computing power margin available for new tasks based on the thread utilization of the device CPU and the task queue depth; for communication bandwidth, the probe module dynamically calculates the bandwidth availability by monitoring the throughput and packet queuing delay of the device network interface.

[0064] When generating the resource adaptation strategy template, the system first normalizes heterogeneous resources according to device capability differences, such as mapping the GPU acceleration capability of high-performance devices to virtual computing units, quantifying the communication interface stability of low-power devices as bandwidth reliability coefficients, and constructing a multi-dimensional resource adaptation scoring table based on this.

[0065] Subsequently, according to the resource demand characteristics of sub-task link units, such as computation-intensive, communication-intensive, or memory-sensitive, the task is decomposed into lightweight execution units: for computation-intensive sub-tasks, preferentially disassemble into parallelizable micro-batch processing units; for communication-intensive sub-tasks, encapsulate into data packet groups with redundancy check, and mark the minimum bandwidth requirement threshold.

[0066] In the dynamic allocation process, the system compares the resource requirements of the lightweight execution unit with the device resource adaptation score in real time. If it is detected that the current load of the target device exceeds the safety threshold of the adaptation score, for example, the computing power occupancy rate of a certain device has reached 90% of the upper limit of the score table, the allocation of new task units to it is immediately suspended, and the resource migration decision is started: according to the resource surplus and communication link quality of the adjacent devices, the highest scoring candidate device is selected as the migration target, and the additional delay loss caused by migration is calculated. If the migration loss exceeds 20% of the real-time performance constraint threshold of the subtask, the migration is abandoned and the task execution unit is decomposed again to a finer granularity of microtasks before being redistributed.

[0067] In addition, when the device resource state suddenly becomes abnormal, such as memory overflow or communication interruption, the resource adaptation engine automatically isolates the faulty device and rolls back the unfinished task units to the standby path according to the resource snapshot of the last healthy state, ensuring the continuity of the task link.

[0068] S4: Embed delay prediction and compensation agents in key nodes of the task link, predict end-to-end delay fluctuations based on historical delay data and device state, and dynamically select redundant execution copies or low-load path switching strategies; When deploying delay prediction and compensation agents in key nodes of the task link, the system first extracts delay feature data of each device based on historical task execution logs, including task processing time, cross-device communication transmission time, and abnormal interruption frequency, and establishes a delay fluctuation prediction model. For example, for communication node devices, the average data packet transmission delay and jitter range under different load states in the past 24 hours are counted, combined with the current device CPU occupancy rate, memory available capacity, and network interface queue depth, to predict the fluctuation interval of the next stage end-to-end delay.

[0069] When the predicted delay exceeds the real-time performance constraint threshold of the subtask link, the system triggers the compensation strategy selection mechanism: if redundant resources such as idle computing power or standby bandwidth are detected in the target device or communication path, redundant execution copies are generated and pre-distributed to standby devices, while the main path task continues to execute; If the redundant resources are insufficient or the generation cost of the redundant copies is too high, for example, the occupied memory exceeds 30% of the available capacity of the device, the low-load path switching strategy is started, the migration path with the smallest delay increment is selected according to the real-time load state of the adjacent devices and the communication link quality, and the priority weight and execution timing of the task link are updated synchronously. For example, when the predicted delay of a certain control instruction transmission path reaches 120% of the threshold, the system preferentially switches to a standby path with a load less than 50% and a communication packet loss rate less than 2%, if the standby path is not available, the redundant copies are executed in parallel on the two paths, and the path that returns the valid result first is selected as the output.

[0070] For unpredictable scenarios caused by sudden device failure, such as physical damage to the communication interface, the compensation agent immediately interrupts the current task execution, rolls back to the last available sub-task node based on the last health status snapshot, and recalculates the priority allocation and path switching scheme for the remaining links while marking the failed device as isolated.

[0071] In addition, after the compensation strategy is executed, the system simulates and replays the key fragments of the task link through the sandbox, verifies whether the end-to-end delay after compensation meets the constraints, and if there is still deviation, iteratively adjusts the parameter weight of the delay prediction model and optimizes the path switching cost evaluation logic.

[0072] S5: Verify the real-time constraint achievement rate of the global scheduling model through offline simulation, and verify the feasibility of the resource migration path and the additional resource overhead of the compensation strategy through online dynamic sandbox. When implementing offline simulation verification, the system first constructs a virtualized heterogeneous device cluster consistent with the real environment, simulates the dynamic task requests and device state disturbances that may occur in multi-device collaborative scenarios. For example, inject randomly generated high real-time task streams in the simulation environment, and simulate abnormal working conditions such as sudden load surge of devices, intermittent interruption of communication links, or instantaneous depletion of computing resources, and perform priority allocation and resource migration operations for task links through the global scheduling model.

[0073] During simulation, the system records the end-to-end delay data of each sub-task link in real time, and calculates the proportion of tasks that meet the real-time constraint threshold as the achievement rate indicator; if it is found that the achievement rate of low-computing-power edge nodes is continuously below 80% of the preset threshold, the decay factor parameter in the priority weight calculation model is dynamically corrected, and the allocation weight of the resource load balancing gradient algorithm is adjusted, such as reducing the task allocation density of high-load devices or increasing the priority compensation value of redundant paths. For priority conflicts exposed in simulation, such as multiple sub-tasks competing for the same device resources, the system traces back the logical dependency relationship of the task link, adjusts the sub-task granularity or introduces an asynchronous execution window through sandbox simulation, and iteratively optimizes the scheduling strategy.

[0074] Further, in the online dynamic sandbox verification phase, the system intercepts a representative task link execution fragment from the real running environment, such as the sensor-controller-actuator closed-loop link in the industrial control scene, and reproduces its resource state and real-time constraint conditions in the sandbox. During verification, resource mutation events are actively injected, such as simulating a sudden memory depletion or a 50% drop in communication bandwidth of a device, triggering resource migration path switching and compensation strategy execution: for example, when a sub-task cannot continue to execute due to insufficient memory of the target device, the sandbox selects an adjacent low-load device as the migration target according to the resource elasticity perception matrix, and calculates the additional communication delay caused by migration; if the delay increment exceeds 30% of the remaining time margin of the sub-task, the migration is abandoned and the task unit is secondarily decomposed, which is split into more fine-grained micro-tasks and then reassigned. At the same time, the sandbox monitors the resource overhead of the compensation strategy, such as the computing power occupied by the redundant copy or the bandwidth consumed during migration, and if the overhead exceeds the preset safety threshold, for example, the overhead exceeds 15% of the total resource occupation, the strategy is marked as a high-risk solution and an alternative strategy is triggered to replace it. After verification, the system feeds back the sandbox running results to the global scheduling module, dynamically updates the resource adaptation strategy template and priority weight calculation rules, such as disabling high-overhead migration paths or optimizing the generation timing of redundant copies; wherein the sandbox running results include migration path feasibility score and compensation strategy overhead proportion.

[0075] The priority weight of each sub-task is dynamically calculated, including:

[0076] Based on the real-time decay factor and resource occupation feedback coefficient, a priority weight calculation model for sub-task links is established;

[0077] When it is detected that the priority of a sub-task cannot be met due to device load or communication delay, a priority compensation request is sent to the associated device through a bidirectional priority negotiation mechanism;

[0078] The device receiving the request adjusts the priority weight and execution timing of the local sub-task according to the current resource state and global demand of the task link.

[0079] It needs to be further explained that in the process of implementation, when dynamically calculating the priority weight of the subtask, the system first establishes an association model of real-time decay factor and resource occupation feedback coefficient for each subtask link unit. The real-time decay factor is dynamically calculated based on the interface type stability parameter of the communication path where the subtask is located, for example, for a wireless communication path, if its historical average packet loss rate exceeds 5%, the initial value of the real-time decay factor is set to 1.2, and it is dynamically adjusted according to the current signal strength, wherein the interface type stability parameter contains the packet loss rate and delay fluctuation of Ethernet, CAN bus or wireless module; the resource occupation feedback coefficient is generated according to the real-time load state of the target device, for example, when the device CPU utilization is higher than 75%, the resource occupation feedback coefficient is increased by a linear proportion, and the highest increase is 1.5; wherein the real-time load state contains CPU utilization, memory occupation rate and task queue length.

[0080] When it is detected that the priority weight calculation result of the subtask is lower than the minimum threshold corresponding to its end-to-end delay requirement, for example, the control instruction subtask weight needs to be ≥0.8 to meet the 50ms delay constraint, but the actual calculation value is 0.6, the system sends a priority compensation request to the associated device that has a dependency relationship with the subtask through a bidirectional priority negotiation mechanism, and the request carries the delay gap value of the current subtask, the device load state and the optional migration path list.

[0081] The device receiving the request evaluates whether the priority weight of the associated subtask can be increased to compensate for the gap according to the real-time data of the local resource elasticity perception matrix, for example, after receiving the compensation request, if the current load of the actuator device is lower than 60% and the communication bandwidth is sufficient, the priority weight of the local associated data processing subtask is increased from 0.7 to 0.9, and the adjusted weight value and the estimated execution completion time are fed back to the global scheduling module; if the device load is too high or the resources are insufficient, the request is refused and the resource limitation parameter is returned, triggering the global scheduling module to select other associated devices or start task migration; wherein the real-time data contains available computing power margin, memory free block and communication bandwidth remaining.

[0082] After the priority adjustment is completed, the system re-sequences the execution timing of the sub-tasks according to the new weight values, for example, inserts the sub-tasks with increased weights at the front end of the device task queue, and delays the execution window of the sub-tasks with low weights. In addition, when multiple associated devices simultaneously initiate compensation requests, causing resource competition, the system arbitrates according to the real-time urgency of the task link: for example, in an industrial control scenario, the request of an emergency shutdown instruction link is prioritized over a regular data acquisition link, directly preempting the resource allocation authority of the target device. Through sandbox simulation, the task execution process after weight adjustment is verified, and if it is found that a device is trapped in load oscillation due to frequent response to compensation requests, such as repeated fluctuations of CPU utilization between 70% and 90%, the weight smoothing algorithm is automatically enabled to limit the number of priority adjustments per unit time, and the load change rate is introduced as a correction parameter of the feedback coefficient.

[0083] The generation of the real-time decay factor includes:

[0084] According to the end-to-end delay requirement of the task link and the stability parameter of the device communication interface, the priority decay value of the sub-task when passing across the device is calculated;

[0085] When the priority decay value exceeds the preset threshold, a priority compensation request is triggered and broadcast to the associated devices. It needs to be further explained that in the process of implementation, when constructing the real-time dependency graph of the task link, the system defines the execution path of the sub-task link unit according to the logical execution flow and data dependency relationship of the multi-device collaborative task. For example, in an industrial control scene, sensor data acquisition, filtering processing, control algorithm operation and actuator driving instruction are disassembled into sequentially executed sub-tasks, and each sub-task is labeled with a real-time constraint threshold: data acquisition must be completed within 10ms, control algorithm operation must not exceed 30ms, and actuator response delay must be less than 20ms. For cross-device communication dependency, the system identifies the device interaction interface type between sub-tasks, and establishes a communication reliability score according to the interface protocol stability parameters; wherein the device interaction interface type includes CAN bus, Ethernet or wireless communication module; the stability parameters include the error frame rate of CAN bus and the signal strength of wireless module. For example, if a sub-task needs to transmit data across devices through a wireless module, the communication stability coefficient of the link is dynamically calculated according to the historical communication success rate of 95% and the current signal strength of -70dBm, and is mapped to the real-time decay factor. When device heterogeneity causes execution path conflict, for example, a high-performance device cannot execute a specific sub-task due to incompatible firmware version, the system automatically traverses the device resource pool, selects a functionally equivalent and interface-compatible backup device, re-plans the sub-task link topology structure, and updates the real-time constraint threshold: for example, after migrating the control algorithm task originally scheduled on the high-performance device to the backup device, due to its lower algorithm power, the real-time threshold of this sub-task is relaxed from 30ms to 40ms, and the execution window of the downstream sub-task is compressed to maintain the end-to-end delay. In addition, when a device state mutation such as a communication interface sudden failure is detected, causing a sub-task link interruption, the system backtracks to the nearest recoverable node based on the real-time dependency graph, generates an alternative execution path and reallocates the real-time constraints, including: for example, when the controller-actuator link is interrupted, switch to the redundant controller path, and dynamically adjust the start time threshold of the actuator sub-task according to the communication delay of the backup path.

[0086] The sandbox simulation verifies the logical topology rationality of the sub-task link. If the deviation between the real-time decay factor and the actual performance of the device exceeds 20%, the graph reconstruction process is triggered, including: re-dividing the sub-task granularity or merging adjacent sub-tasks with low delay requirements to optimize the transmission efficiency of global real-time constraints.

[0087] The execution of the bidirectional priority negotiation mechanism includes:

[0088] The device receiving the priority compensation request reallocates the priority weight of the local task based on the real-time data of the resource elasticity perception matrix;

[0089] The adjusted priority weight is fed back to the task link global scheduling module, and the execution time sequence of the sub-task link is updated.

[0090] It needs to be further explained that in the specific implementation process, after receiving the priority compensation request, the device first parses the delay gap value and the optional migration path list in the request, and combines the real-time data of the local resource elasticity perception matrix to evaluate the strategy. For example, when a certain controller device receives a request to raise the priority of a data processing sub-task, the system checks the algorithm power demand associated with the sub-task and the current CPU remaining capacity: if the remaining algorithm power is sufficient to cover the priority elevation required in the request, for example, to raise the weight from 0.7 to 0.9 requires an additional 15% CPU resources, and the device currently has 20% remaining algorithm power, the local task queue is immediately adjusted, the sub-task is inserted into the high-priority execution window, and the required memory blocks and communication bandwidth are pre-allocated; if the remaining algorithm power is only 5%, such as in the case of insufficient resources, the migration path list is traversed, the standby device with the smallest communication delay increment is selected, such as the adjacent edge node, the sub-task is migrated to the device after being split, and the split execution scheme and the adjusted real-time threshold are sent to the global scheduling module.

[0091] For sub-tasks that rely on multi-device collaboration, such as sensor-controller-actuator links, the device needs to synchronize the resource preparation status of the downstream device after adjusting the local priority: for example, after the controller raises the algorithm operation priority, the actuator device needs to detect the remaining capacity of the instruction reception buffer, if the buffer is about to be full, the output rhythm of the high-priority task is delayed to avoid data loss. When multiple compensation requests arrive simultaneously, causing local resource conflicts, the device arbitrates according to the global real-time level of the task link: emergency safety tasks, such as device emergency stop instructions, have priority in resource allocation, and regular tasks enter the waiting queue and are marked as interruptable.

[0092] After the adjustment is completed, the device feeds back the new priority weight, the estimated execution time, and the resource occupation change to the global module, triggering the state synchronization of the associated devices. For example, after completing the priority elevation, the actuator device needs to notify the upstream controller to send data packets in advance to avoid time-consuming empty waiting, and update the task trigger condition of the downstream state monitoring device. If the migration path is disabled due to sudden communication failure, such as the standby device being offline, the device rolls back to the original priority configuration and triggers a global alarm to start the redundant link reconstruction process. Through sandbox simulation, if the priority elevation causes the real-time performance of other sub-tasks to deteriorate, such as a data acquisition task being delayed beyond the limit due to resource being preempted, the weight balancing algorithm is enabled to dynamically release part of the resources to low-priority tasks while meeting the constraints of the core link.

[0093] The generation of the resource adaptation strategy template includes:

[0094] The computing power, memory and communication bandwidth of the heterogeneous device are abstracted as a virtual resource pool that can be dynamically mapped;

[0095] The lightweight execution unit is dynamically allocated according to the real-time load state of the device through a resource load balancing gradient algorithm, and a real-time loss evaluation parameter of the resource migration path is generated.

[0096] It should be further explained that in the specific implementation process, when generating the resource adaptation strategy template, the system first normalizes the computing power, memory and communication bandwidth of the heterogeneous device, such as converting the GPU parallel processing capability of a high-performance computing device into a standard computing power unit, quantifying the communication interface stability of a low-power embedded device into a bandwidth reliability level, and constructing a multi-dimensional resource adaptation score table based on this. For devices of different resource types, such as compute-intensive nodes, high-memory-demand nodes or low-latency communication nodes, the system dynamically divides the resource demand categories of the lightweight execution unit: for image processing tasks, the tasks are broken down into micro-batch processing units that can be executed in parallel and labeled with GPU computing power demand levels; for real-time control instructions, encapsulate the data packet group with timestamp verification and set the maximum communication delay tolerance value. During dynamic allocation, the system monitors the changes in the resource adaptation score of the target device in real time: if the computing power utilization rate of a device exceeds the safety threshold of the score table, for example, the maximum computing power utilization allowed in the score table is 85%, but the current utilization is 90%, then the allocation of compute-intensive task units to this device is suspended, and a resource migration decision is started.

[0097] The candidate target with the highest resource adaptation score and up-to-standard communication link quality among the neighboring devices is preferentially selected during migration, for example, the task unit is migrated to an edge node with a computing power utilization rate of less than 70% and a communication packet loss rate of less than 1%, and the additional delay loss caused by migration is calculated. If the loss exceeds 25% of the remaining time margin of the subtask, the migration is abandoned and the task unit is decomposed again: the original task is split into finer-grained submodules, such as image processing tasks are split into regional block processing and allocated to multiple low-load devices for parallel execution, while the real-time threshold of each submodule is adjusted to match the execution logic after decomposition.

[0098] When a device has a sudden resource anomaly, such as a memory overflow that causes a task execution failure, the system rolls back the unfinished task to the latest stable state based on the historical health snapshot of the resource elasticity perception matrix, and reallocates it to a backup path device for execution: for example, after a data processing task is interrupted due to a memory anomaly in the target device, the system automatically switches to a backup device that has been verified to be available three days ago, and recalculates the start delay compensation value of the task according to the current communication link quality.

[0099] Further, for the working condition of instantaneous bandwidth drop of communication, such as network congestion causing the bandwidth to drop to 60% of the demand value, the system dynamically enables the data compression transmission mode to reduce the amount of data transmitted at a time and increase the transmission frequency to maintain the overall data throughput, while updating the bandwidth reliability parameter in the resource adaptation score table. Through sandbox simulation, the effectiveness of the resource migration path is verified, and if it is found that the end-to-end delay after migration still exceeds the constraint threshold, the path is marked as a high-risk solution and the dynamic load balancing strategy is triggered to redistribute the migrated task units among adjacent devices according to the score ratio.

[0100] The real-time loss evaluation parameter of the resource migration path is used for:

[0101] When the device resource state mutates, the execution of the unfinished task unit is interrupted;

[0102] The priority weight is recalculated according to the real-time loss evaluation parameter, and the mapping relationship of the virtual resource pool is updated after the task unit is migrated to the target device.

[0103] It needs to be further explained that in the specific implementation process, when triggering the resource elasticity adaptation feedback loop, the system first monitors the device resource state mutation event in real time, such as the instantaneous memory usage exceeding 95% or the communication bandwidth dropping below 50% of the demand value, immediately interrupts the current task execution process of the affected device, and marks the unfinished task unit as a migration state. For example, when a certain edge computing node is interrupted due to sudden memory overflow, the system freezes the context state of the task, including the processed data block pointer, the calculation intermediate result and the data buffer to be transmitted, and then generates a priority weight calculation request according to the real-time loss evaluation parameter of the resource migration path, such as the estimated communication delay of migrating to the standby device, the remaining amount of the target device and the task restart time cost.

[0104] If the evaluation finds that the delay loss of migrating to the preferred standby device exceeds 30% of the remaining time of the subtask, for example, the remaining available time of the subtask is 50ms, and the migration causes the delay to increase by 15ms, then the direct migration is abandoned and the task unit is decomposed twice: the original task is divided into independent executable microtask modules, such as dividing the image recognition task into four subblocks according to the area, and assigning them to multiple low-load devices for parallel processing, while assigning an independent real-time constraint threshold to each microtask module, such as splitting the total delay threshold by the number of subblocks.

[0105] When the target standby device is insufficient in resources, such as the available memory being lower than the minimum requirement of the microtask, the system traverses the adjacent device list in the resource elasticity perception matrix, selects a device with suboptimal communication link quality but sufficient resources as an alternative target, and dynamically adjusts the priority weight of the migration path, such as reducing the communication bandwidth score weight and increasing the remaining amount of the weight.

[0106] After migration is completed, the system updates the mapping relationship of the virtual resource pool, including, for example, marking the original device as "restricted state" and reducing its resource adaptation score, while increasing the load coefficient of the target device to avoid excessive allocation of subsequent tasks. For extreme scenarios where the migration path is completely disabled due to communication interruption, such as offline backup devices, the system rolls back to the last available state based on historical health snapshots and simulates a local resource reconstruction scheme in a sandbox, including, for example, isolating the faulty device and enabling redundant communication links, rebinding task units to devices on the redundant path for execution, and compressing the execution window of subsequent sub-tasks to compensate for rollback time consumption. In addition, when detecting resource contention during the execution of the migrated task, such as multiple micro-tasks competing for the GPU resources of the same device, the system dynamically adjusts the execution timing according to the urgency of real-time performance: emergency micro-tasks are given priority to obtain resource locks, non-critical tasks enter a polling waiting queue, and a timeout interrupt mechanism is set, such as triggering a second migration if waiting for more than 20ms.

[0107] After migration is completed, the system updates the mapping relationship of the virtual resource pool, including, for example, marking the original device as "restricted state" and reducing its resource adaptation score, while increasing the load coefficient of the target device to avoid excessive allocation of subsequent tasks. For extreme scenarios where the migration path is completely disabled due to communication interruption, such as offline backup devices, the system rolls back to the last available state based on historical health snapshots and simulates a local resource reconstruction scheme in a sandbox, including, for example, isolating the faulty device and enabling redundant communication links, rebinding task units to devices on the redundant path for execution, and compressing the execution window of subsequent sub-tasks to compensate for rollback time consumption. In addition, when detecting resource contention during the execution of the migrated task, such as multiple micro-tasks competing for the GPU resources of the same device, the system dynamically adjusts the execution timing according to the urgency of real-time performance: emergency micro-tasks are given priority to obtain resource locks, non-critical tasks enter a polling waiting queue, and a timeout interrupt mechanism is set, such as triggering a second migration if waiting for more than 20ms.

[0108] The execution of the delay prediction and compensation agent includes:

[0109] Redundant execution copies are pre-embedded at the communication nodes of the task link, and the end-to-end delay fluctuation range is predicted based on the device state;

[0110] If the predicted delay exceeds the real-time constraint threshold, start the redundant copy or switch to the low-load path, and select the compensation strategy with the smallest resource overhead through the path switching cost evaluation function.

[0111] Further, in the process of delay prediction and compensation agent execution, the system pre-embeds redundant execution copies to the key nodes of the standby path based on the historical execution log of the task link and real-time device state data. For example, at the communication node where the controller sends control instructions to the actuator, two copies of data are generated synchronously and cached in the temporary memory pool of the adjacent edge device, while the real-time communication quality of the main path is monitored, such as packet transmission success rate and delay jitter. When the prediction model detects that the end-to-end delay fluctuation of the main path may exceed the real-time constraint threshold, for example, the predicted delay reaches 120% of the threshold and the fluctuation amplitude continues to expand, the system selects the optimal compensation strategy according to the path switching cost evaluation function: if the communication stability score of the main path is higher than that of the standby path, such as the packet loss rate of the main path is 2% and that of the standby path is 5%, then the redundant copies are preferentially enabled for parallel transmission, and the execution of other copies is terminated after the first valid result arrives; if the load score of the standby path is significantly better than that of the main path, such as the CPU occupancy rate of the standby path device is lower than 40% and that of the main path device is 80%, then the standby path is directly switched to and the priority weight of the subsequent sub-tasks is adjusted. For sudden communication interruption, such as the main path device going offline, the compensation agent immediately activates the redundant copy execution process and dynamically adjusts the task parameters based on the device capabilities of the standby path: for example, when the standby device has low computing power, the calculation precision of the control algorithm is downgraded from floating-point operation to fixed-point operation to shorten the processing time, and the data packet length is compressed to reduce communication time consumption. If the redundant copy cannot be generated due to resource limitations, such as insufficient memory of the standby device, the path dynamic switching strategy is started: all reachable devices in the resource elasticity perception matrix are traversed, the path with the smallest communication delay increment is selected, such as migrating to a device with a delay increase of 10 ms but a load lower than 50%, and the execution time window of the downstream sub-tasks is updated synchronously, such as adjusting the actuator response delay threshold from 20 ms to 25 ms.

[0112] After the compensation strategy is executed, the system verifies the actual improvement effect of the end-to-end delay through sandbox playback: if the delay after compensation still exceeds the threshold by more than 5%, trigger the iteration optimization of the compensation strategy, such as increasing the number of redundant copies or shortening the path switching decision period; if the resource overhead is too high after compensation, such as the redundant copies occupying 30% of the total bandwidth, then fall back to the baseline strategy and mark this scenario as a high-risk working condition, and subsequently prefer to use task unit secondary decomposition instead of compensation.

[0113] In addition, when a priority conflict is detected due to multi-path switching, such as two standby paths responding simultaneously causing data duplication, the system arbitrates based on the globally unique identifier of the task link, only retains the task flow with the first valid result, and forcibly terminates other redundant processes to release resources.

[0114] Offline simulation verification includes:

[0115] Injecting random task requests and device failure disturbances in the virtualized heterogeneous device cluster, and counting the real-time constraint achievement rate of the global scheduling model;

[0116] According to the simulation results, the attenuation factor threshold in the priority weight calculation model and the allocation parameters of the resource load balancing gradient algorithm are dynamically corrected.

[0117] It should be further explained that, in the specific implementation process, when implementing offline simulation verification, the system constructs a virtualized cluster containing heterogeneous device nodes, simulating the task execution environment of multi-device cooperation in a real industrial scene. For example, high-performance industrial computers, low-power edge nodes, and communication gateway devices are deployed in the cluster, and are configured with differentiated resource parameters, such as 8 cores and 16 GB of memory for the CPU cores of the industrial computer, and 4 cores and 4 GB of memory for the edge node.

[0118] During the simulation, dynamic task streams are injected, including periodic control instructions, burst data processing requests, and random device failure events, such as simulating a CPU occupancy rate of a certain edge node rising to 90% for 10 seconds every 5 minutes. The system executes the global scheduling model, records the end-to-end delay data of each sub-task link in real time, and counts the proportion of tasks that meet the real-time constraints as the achievement rate indicator: if the achievement rate of a certain device group is continuously below the preset threshold, such as the achievement rate of low-power nodes being below 75%, the attenuation factor parameter of the priority weight calculation model is dynamically adjusted, for example, the priority attenuation coefficient of high-load devices is increased from 1.2 to 1.5 to reduce the task allocation density; at the same time, the allocation weight of the resource load balancing gradient algorithm is optimized, for example, the bandwidth margin weight proportion of communication-intensive tasks is increased, and the influence of the computing power demand weight is reduced.

[0119] When the simulation detects priority conflicts, such as multiple sub-tasks competing for the GPU resources of the same device causing queue blocking, the system traces back the logical dependency relationship of the task link and adjusts the strategy locally through sandbox simulation: for example, an image processing task originally scheduled to be executed on a single device is split into two parallel sub-tasks and assigned to the idle GPU units of adjacent devices, and an asynchronous execution window is set for them, such as sub-task A executing from 0-30ms and sub-task B executing from 10-40ms, avoiding resource contention. If the delay exceeds after splitting, such as sub-task A being delayed to 35ms due to device load fluctuations, a dynamic priority preemption mechanism is further introduced, including: allowing high real-time tasks to preempt the resources of low-priority tasks within a certain time window, and reserving a compensation execution period for the interrupted task after preemption.

[0120] After the simulation is completed, the system generates a model parameter correction scheme based on the achievement rate distribution and conflict resolution records: for example, increase the weight of the communication link stability parameter from 20% to 30%, and limit the number of sub-tasks executed by a single device to no more than twice the number of CPU cores. For extreme conditions exposed in the simulation, such as three device nodes failing simultaneously, the system marks it as a high-risk scenario and triggers the elastic resource pool expansion strategy: automatically reserve at least two backup device nodes for critical task links in subsequent scheduling, and allocate them the minimum guaranteed resource quota, such as 10% of the computing power and memory.

[0121] Through multiple rounds of iterative simulation verification, the system gradually converges to the optimal parameter combination, ensuring the robustness and real-time performance of the global scheduling model in dynamic heterogeneous environments.

[0122] Online dynamic sandbox verification includes:

[0123] Intercept the execution segment of the task link in the real scene, simulate the switching process of the resource migration path;

[0124] Through sandbox verification, filter whether the additional resource overhead of the compensation strategy is lower than the preset threshold, and feed back to the global scheduling module for strategy iteration optimization.

[0125] It needs to be further explained that in the implementation process, when implementing online dynamic sandbox verification, the system dynamically intercepts typical execution segments of task links from real running environments, such as the complete link from sensor data acquisition to motion command generation in the industrial robot arm control scene, and reconstructs its execution environment in the sandbox, including device resource snapshot and real-time constraint conditions, device resource snapshot includes CPU occupancy, memory distribution and communication bandwidth utilization. For example, for a closed-loop control link, the sandbox accurately reproduces the current load of the controller device and the communication delay baseline of the actuator interface, and then actively injects resource mutation events, including: simulate the sudden depletion of the controller memory to 95% or the sudden drop of the communication bandwidth to 40% of the original value, trigger the coordinated response of the resource elasticity adaptation feedback loop and the delay compensation agent. When the sandbox detects the feasibility of resource migration path, such as migrating the unfinished data processing task to an edge node with 40% of the remaining computing power and 50% of the free memory, it calculates the additional delay loss and resource overhead caused by real-time migration: if the migration delay increment exceeds 35% of the remaining time margin of the sub-task, for example, 18ms is added to the remaining 50ms, then give up direct migration and start secondary decomposition of the task unit, split it into two micro-task modules, such as feature extraction and result aggregation, and assign them to two low-load devices for parallel execution, and set independent real-time thresholds for each module, such as feature extraction needs to be completed within 25ms, and aggregation needs to be completed within 15ms.

[0126] Meanwhile, the sandbox monitors the resource overhead of the compensation strategy, such as the total memory occupied by the redundant copy or the peak bandwidth consumed in the migration process. If it is detected that the total overhead of a certain strategy exceeds the preset safety threshold, such as 25% of the total bandwidth of the system, the strategy is marked as a high-risk solution, and an alternative strategy is triggered to replace it: for example, disabling the generation of redundant copies and instead dynamically reducing the execution accuracy of the task, such as reducing the number of iterations of the control algorithm from 100 to 80, to compress the resource demand. After verification, the system feeds back the sandbox running results to the global scheduling module, dynamically updates the device compatibility parameters and priority weight calculation rules in the resource adaptation strategy template, wherein the sandbox running results include migration path scores, compensation strategy effectiveness, and resource overhead proportion. For example, when a migration path fails three times in the sandbox due to large communication delay fluctuations, it is removed from the list of optional paths in the resource elasticity perception matrix, and the communication stability score weight of the associated device is reduced; if the resource overhead of a compensation strategy is less than 10% in five verifications and the delay compliance rate exceeds 90%, its strategy priority is increased, and the path switching decision cycle is shortened to 50% of the original value. For extreme working conditions, such as two consecutive migration attempts failing, the sandbox automatically generates an emergency execution scheme, including, for example, bypassing the regular task decomposition process and directly enabling a high-power backup device to take over the entire link task, and dynamically compressing the execution window of non-critical sub-tasks, such as relaxing the delay threshold of the log recording task from 50ms to 80ms, to ensure the real-time performance of the core link. The verification data is finally integrated into the offline simulation model for iterative optimization of the robustness parameters and exception handling logic of the global scheduling algorithm.

[0127] A multi-device collaborative control system applied to embedded real-time operating system deployment, comprising:

[0128] A task link analysis module for constructing a real-time dependency graph and decomposing sub-task link units;

[0129] A dynamic priority scheduling module for executing a priority weight calculation model and a bidirectional priority negotiation mechanism;

[0130] A resource elasticity adaptation module for managing a virtual resource pool and generating a resource adaptation strategy template;

[0131] A real-time compensation module for deploying a delay prediction agent and a path switching strategy;

[0132] A verification engine module for performing dual verification of offline simulation and online dynamic sandbox.

[0133] Through implementation of the technical solution, the system realizes global dynamic coordination of task priority and real-time constraints in a multi-device heterogeneous environment, solves the problem of resource utilization imbalance and real-time conflict caused by local optimization in traditional methods, and significantly improves the reliability and efficiency of the embedded real-time operating system in a multi-device coordination scenario.

[0134] Through the dynamic priority transmission mechanism and the distributed resource elasticity perception model, the problem of task priority conflict and resource utilization imbalance in a multi-device heterogeneous environment is effectively solved. The system can perceive device load, communication link stability and task real-time requirements in real time, dynamically adjust subtask weight and execution path, ensure conflict-free transmission of end-to-end delay constraints, optimize global resource utilization, and avoid the problem of device overload or idling caused by traditional static scheduling.

[0135] Combined with the cross-device real-time compensation algorithm and the double verification mechanism, the robustness and adaptability of the system in a dynamic disturbance scenario are improved. Through strategies such as redundant copy pre-embedding, path dynamic switching and task unit secondary decomposition, the system can quickly respond to device failures or resource mutations, ensuring the real-time performance of the core link; the double verification framework of offline simulation and online sandbox ensures the reliable landing of the scheduling strategy in complex environments, thereby realizing high-reliability, low-latency multi-device collaborative control in the fields of industrial automation and intelligent Internet of Things.

[0136] It should be noted that, in this article, relationship terms such as first and second are used only to distinguish one entity or operation from another, and do not necessarily require or imply any such actual relationship or order between the entities or operations. Moreover, the terms "include", "contain" or any other variant thereof are intended to cover non-exclusive inclusion, so that the process, method, article or device including a series of elements not only includes those elements, but also includes other elements not explicitly listed or inherent to such process, method, article or device. Without more limitations, the element defined by the statement "including a" does not exclude the presence of another identical element in the process, method, article or device including the element.

[0137] Although embodiments of the present application have been shown and described, it will be understood by those of ordinary skill in the art that various changes, modifications, substitutions and alterations can be made thereto without departing from the principles and spirit of the present application, and the scope of the present application is defined by the appended claims and their equivalents.

Claims

1. A multi-device collaborative control method applied to embedded real-time operating system deployment, characterized in that, Includes the following steps: S1: Construct a real-time dependency graph of the task chain, and decompose multi-device collaborative tasks into sub-task chain units that include execution paths, real-time constraint thresholds and cross-device communication dependencies; S2: Dynamically calculate the priority weight of each subtask based on the end-to-end latency requirements of the subtask link unit, the device load status, and the stability of the communication link. S3: Real-time collection of computing power, memory and communication bandwidth data of heterogeneous devices through distributed resource probes, generation of resource adaptation strategy templates, decomposition of tasks into lightweight execution units that adapt to the capabilities of different devices and dynamic allocation to low-load devices. S4: Embed latency prediction and compensation agents at key nodes in the task chain, predict end-to-end latency fluctuations based on historical latency data and device status, and dynamically select redundant execution replicas or low-load path switching strategies. S5: Verify the real-time constraint achievement rate of the global scheduling model through offline simulation, and verify the feasibility of resource migration paths and the additional resource overhead of compensation strategies through online dynamic sandbox. The dynamic calculation of the priority weights of each subtask includes: A priority weight calculation model for subtask links is established based on the real-time decay factor and resource consumption feedback coefficient. When it is detected that a subtask cannot meet the priority due to device load or communication delay, a priority compensation request is sent to the associated device through a two-way priority negotiation mechanism. The receiving device adaptively adjusts the priority weight and execution sequence of local subtasks based on the current resource status and the global requirements of the task chain.

2. The multi-device collaborative control method for embedded real-time operating system deployment according to claim 1, characterized in that: The generation of the real-time decay factor includes: Based on the end-to-end latency requirements of the task chain and the stability parameters of the device communication interface, calculate the priority decay value of the subtask when it is transmitted across devices. When the priority decay value exceeds the preset threshold, a priority compensation request is triggered and broadcast to the associated device.

3. The multi-device collaborative control method for embedded real-time operating system deployment according to claim 2, characterized in that: The execution of the two-way priority negotiation mechanism includes: The device receiving the priority compensation request reallocates the priority weights of local tasks based on real-time data from the resource elasticity awareness matrix. The adjusted priority weights are fed back to the task chain global scheduling module, and the execution sequence of the sub-task chains is updated.

4. The multi-device collaborative control method for embedded real-time operating system deployment according to claim 1, characterized in that: The generation of the resource adaptation strategy template includes: Abstract the computing power, memory, and communication bandwidth of heterogeneous devices into a dynamically mappable virtual resource pool; The lightweight execution unit is dynamically allocated according to the real-time load status of the device through the resource load balancing gradient algorithm, and real-time loss assessment parameters of the resource migration path are generated.

5. The multi-device collaborative control method for embedded real-time operating system deployment according to claim 4, characterized in that: The real-time performance loss assessment parameters for the resource migration path are used for: When the device resource state changes abruptly, the execution of unfinished task units is interrupted; Priority weights are recalculated based on real-time loss assessment parameters, and the mapping relationship of the virtual resource pool is updated after the task units are migrated to the target device.

6. The multi-device collaborative control method for embedded real-time operating system deployment according to claim 1, characterized in that: The execution of the delay prediction and compensation agent includes: Redundant execution copies are pre-embedded in the communication nodes of the task link, and the end-to-end latency fluctuation range is predicted based on the device status. If the predicted latency exceeds the real-time constraint threshold, a redundant replica is activated or the path is switched to a low-load path. The compensation strategy with the lowest resource overhead is selected through the path switching cost evaluation function.

7. The multi-device collaborative control method for embedded real-time operating system deployment according to claim 1, characterized in that: The offline simulation verification includes: Inject random task requests and device fault disturbances into a virtualized heterogeneous device cluster, and statistically analyze the real-time constraint achievement rate of the global scheduling model. The attenuation factor threshold and the allocation parameters of the resource load balancing gradient algorithm in the priority weight calculation model are dynamically adjusted based on the simulation results.

8. The multi-device collaborative control method for embedded real-time operating system deployment according to claim 1, characterized in that: The online dynamic sandbox verification includes: Capture execution segments of the task chain in a real-world scenario to simulate the switching process of resource migration paths; The sandbox verification process checks whether the additional resource overhead of the compensation strategy is lower than a preset threshold, and then feeds back to the global scheduling module for iterative optimization of the strategy.

9. A multi-device collaborative control system applied to embedded real-time operating system deployment, characterized in that, The multi-device collaborative control system is applied to the multi-device collaborative control method for embedded real-time operating system deployment as described in any one of claims 1 to 8, comprising: The task link parsing module is used to construct a real-time dependency graph and decompose sub-task link units; The dynamic priority scheduling module is used to execute the priority weight calculation model and the two-way priority negotiation mechanism; The resource elastic adaptation module is used to manage the virtual resource pool and generate resource adaptation strategy templates; The real-time compensation module is used to deploy latency prediction agents and path switching strategies; The verification engine module is used to perform dual verification, including offline simulation and online dynamic sandbox.

Images