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

Abstract

The invention discloses a multi-device cooperative control method applied to deployment of an embedded real-time operating system, and relates to the field of embedded real-time operating systems, which comprises the following steps of: S1, constructing a real-time dependency relationship graph of a task link, a multi-device cooperative task is disassembled into sub-task link units including an execution path, a real-time constraint threshold and a cross-device communication dependency relationship. According to the multi-device cooperative control method applied to the deployment of the embedded real-time operating system, the problems of task priority conflict and resource utilization imbalance in a multi-device heterogeneous environment are effectively solved through a dynamic priority transmission mechanism and a distributed resource elastic perception model. The system can sense equipment load, communication link stability and task real-time requirements in real time, dynamically adjust sub-task weights and execution paths, ensure conflict-free transmission of end-to-end delay constraints, optimize the global resource utilization rate and avoid the problem of equipment overload or idle caused by traditional static scheduling.

Description

Technical Field

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

[0002] Embedded real-time operating systems, as core enabling technologies in fields such as industrial automation and the intelligent Internet of Things, are gradually evolving towards multi-device collaborative control. Traditional multi-device collaborative solutions are typically based on preset static task priorities and fixed resource allocation models. These solutions can meet basic real-time requirements in scenarios with a single device type and stable task demands. However, with the increasing diversity of industrial field equipment and the continuous increase in task complexity, device heterogeneity is becoming increasingly prominent. Devices with varying computing power, communication interfaces, and real-time performance levels coexist in the same system, gradually exposing the limitations of traditional collaborative control approaches. Existing technologies often employ localized scheduling strategies, implementing priority management within individual devices or groups of homogeneous devices, lacking a global coordination mechanism across multiple devices. This fragmented scheduling model can easily lead to task execution conflicts between multiple devices. For example, high-priority tasks may miss their deadlines due to cross-device communication delays, or low-load devices may remain idle due to a lack of global resource awareness. Furthermore, fluctuations in task demands and changes in device status in dynamic environments further exacerbate system uncertainty. Fixed priority allocation mechanisms are unable to adapt to the dynamic adjustments required to meet real-time constraints. Some solutions attempt to mitigate this conflict by adding redundant resources or improving the performance of individual devices. However, these approaches not only waste resources but also fail to fundamentally address the real-time delivery and resource coordination challenges faced by multi-device collaboration. Existing technologies still have significant shortcomings in achieving globally optimized collaborative scheduling of task priorities and real-time constraints in a dynamic, heterogeneous multi-device environment. Summary of the Invention

[0003] (1) Technical problems solved In response to the shortcomings of the existing technology, the present invention provides a multi-device collaborative control method applied to the deployment of embedded real-time operating systems, which solves the problem of how to build a global adaptive collaborative scheduling mechanism in a complex environment where device heterogeneity, task dynamics and resource distribution are intertwined, to ensure the conflict-free transmission of real-time constraints of multi-device task links and efficient resource utilization.

[0004] (2) Technical solution To achieve the above objectives, the present invention is implemented through the following technical solutions: a multi-device collaborative control method applied to embedded real-time operating system deployment, comprising the following steps: S1: Build a real-time dependency graph for the task chain, breaking down 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 delay requirements of the subtask link unit, the device load status, and the stability of the communication link; S3: Distributed resource probes collect real-time computing power, memory, and communication bandwidth data from heterogeneous devices to generate resource adaptation policy templates. This decomposes tasks into lightweight execution units adapted to different device capabilities and dynamically allocates them to low-load devices. S4: Delay prediction and compensation agents are embedded in key nodes of the task chain. They predict end-to-end delay fluctuations based on historical delay 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 the resource migration path and the additional resource overhead of the compensation strategy through online dynamic sandbox.

[0005] When constructing a real-time dependency graph for a task chain, the system breaks down tasks into subtask chain units with clear input-output relationships based on the data flow and logical execution order within multi-device collaborative tasks. Each subtask unit must define its execution path, real-time constraint thresholds, and cross-device communication dependencies. Execution path planning incorporates device function mappings. For example, in industrial control scenarios, sensor data acquisition subtasks must be bound to devices with specific interface protocols, control algorithm computation subtasks must be assigned to high-computing devices, and actuator driving subtasks must be deployed to low-latency communication devices. Real-time constraint thresholds are broken down hierarchically based on the end-to-end latency requirements of the task chain. For example, the total latency threshold is broken down into phased completion time limits based on the subtask execution order and dynamically adjusted based on device status. Establishing cross-device communication dependencies requires analyzing interface compatibility between subtasks. For example, if a subtask requires data transmission via a wireless communication module, the protocol parsing capabilities and signal coverage of the receiving device must be verified. If a protocol mismatch or insufficient signal strength is detected, an alternative communication path is automatically selected and the dependency relationships updated.

[0006] Preferably, the dynamic calculation of the priority weight of each subtask includes: Based on the real-time attenuation factor and resource occupancy feedback coefficient, a priority weight calculation model for subtask links is established; 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 device receiving the request adaptively adjusts the priority weight and execution timing of the local subtask based on the current resource status and the global requirements of the task link.

[0007] When dynamically calculating the priority weights of subtasks, the system collects the load status of the target device, the communication link stability parameters, and the real-time constraint thresholds of the subtasks in real time, and generates dynamic weight values ​​through the priority weight calculation model. The evaluation of the device load status includes computing power utilization, memory usage, and task queue length. For example, when the computing power utilization of a device is continuously higher than the safety threshold, the priority weights of its associated subtasks are attenuated according to preset rules. The communication link stability parameters are calculated by combining the historical transmission success rate and the real-time signal quality. For example, for wireless communication paths, if the signal strength is below the acceptable range and the packet loss rate increases, an attenuation coefficient is applied to the weights of subtasks that rely on this 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 subtask has insufficient remaining time due to upstream delays, the system proportionally increases its priority weight to accelerate execution.

[0008] Preferably, the generation of the real-time attenuation factor includes: Calculate the priority attenuation value of subtasks when transferring across devices based on the end-to-end delay requirement of the task link and the stability parameters of the device communication interface; When the priority attenuation value exceeds a preset threshold, a priority compensation request is triggered and broadcast to associated devices.

[0009] Preferably, 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 the real-time data of the resource elasticity perception matrix; The adjusted priority weight is fed back to the task link global scheduling module, and the execution timing of the subtask link is updated.

[0010] Preferably, the generation of the resource adaptation policy template includes: Abstract the computing power, memory, and communication bandwidth of heterogeneous devices into a dynamically mapped virtual resource pool; Through the resource load balancing gradient algorithm, lightweight execution units are dynamically allocated according to the real-time load status of the device, and real-time loss evaluation parameters of the resource migration path are generated.

[0011] When generating resource adaptation policy templates, the system abstracts the resource capabilities of heterogeneous devices into dynamically mappable virtual resource pools and collects device status data in real time through distributed resource probes. The resource probe module periodically monitors the device's computing power headroom, free memory blocks, and communication bandwidth availability, and aggregates this data into the resource adaptation engine. The engine generates adaptation policies based on the resource requirements of each task unit, such as matching compute-intensive tasks with high-computing power devices and allocating high-bandwidth links to communication-intensive tasks. Resource requirements can be compute-intensive, memory-sensitive, or communication-intensive. During dynamic allocation, the system compares device resource status with task requirements in real time. If the target device's resource headroom falls below the task's safety threshold, task migration or secondary decomposition is triggered. For example, if a high-computing power device is unable to handle a compute-intensive task due to sudden load, the system splits it into multiple microtask units and distributes them to multiple lower-load devices for parallel execution. The system also adjusts the real-time threshold of each microtask to align with the decomposed execution logic.

[0012] Preferably, the real-time loss assessment parameter of the resource migration path is used to: When the device resource status suddenly changes, the execution of unfinished task units is interrupted; The priority weight is recalculated according to the real-time loss assessment parameter, and the mapping relationship of the virtual resource pool is updated after the task unit is migrated to the target device.

[0013] Preferably, the execution of the delay prediction and compensation agent includes: Redundant execution replicas are embedded in the communication nodes of the task link, and the end-to-end delay fluctuation range is predicted based on the device status; If the predicted delay exceeds the real-time constraint threshold, a redundant replica is started or a switch is made to a low-load path, and the compensation strategy with the lowest resource overhead is selected through the path switching cost evaluation function.

[0014] 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, it predicts end-to-end delay fluctuations and triggers compensation strategies. When the agent module detects a delay risk, it selects the optimal compensation solution based on the path switching cost evaluation function: if the communication quality of the main path deteriorates but the backup path has sufficient resources, redundant execution copies are generated for parallel transmission; if the backup path load is significantly lower than the main path, the execution path is directly switched and the priority of subsequent subtasks is adjusted. For example, at the instruction transmission node from the controller to the executor, if the delay prediction of the main path 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 instruction is delivered on time. For sudden communication interruption scenarios, the agent rolls back to the most recently available state based on the device health snapshot and reconstructs the task link topology. For example, tasks of the interrupted node are migrated to redundant devices, while the execution window of downstream subtasks is compressed to compensate for the migration time.

[0015] Preferably, the offline simulation verification includes: Inject random task requests and device failure disturbances into a virtualized heterogeneous device cluster and calculate the real-time constraint achievement rate of the global scheduling model. The attenuation factor threshold in the priority weight calculation model and the allocation parameters of the resource load balancing gradient algorithm are dynamically modified according to the simulation results.

[0016] During the offline simulation verification phase, the system constructs a virtualized heterogeneous device cluster to simulate task requests and device disturbances in real-world scenarios, verifying the real-time constraint achievement rate and robustness of the global scheduling model. During the simulation, random task flows and device failure events are injected, such as periodically generating high-real-time control instructions to simulate sudden device load surges or communication link interruptions. The system records the end-to-end latency data of each subtask and calculates the achievement rate. If the achievement rate of a certain type of device group continues to fall below the preset standard, the priority attenuation factor and resource allocation weight are dynamically adjusted. For example, when the achievement rate of a low-computing power device group is insufficient, its task allocation density is reduced and the priority compensation value of redundant paths is increased. For priority conflicts exposed in the simulation, the system uses sandbox simulation to implement local optimization strategies, such as splitting competing resource tasks or introducing asynchronous execution windows, to iteratively optimize scheduling parameters.

[0017] Preferably, the online dynamic sandbox verification includes: Intercept the execution fragments of task links in real scenarios and simulate the switching process of resource migration paths; The sandbox verifies whether the additional resource overhead of the screening compensation strategy is lower than the preset threshold, and feeds back to the global scheduling module for strategy iterative optimization.

[0018] During the online dynamic sandbox verification phase, the system captures task link fragments in real scenarios, reproduces their resource status and real-time constraints, and injects controllable abnormal events to verify the effectiveness of the compensation strategy. For example, in the robotic arm control link, the system simulates the memory exhaustion of a controller to trigger the resource migration and task decomposition process. The sandbox monitors the feasibility of the migration path and the resource overhead of the compensation strategy in real time. If the migration delay exceeds the remaining time margin of the subtask or the resource consumption exceeds the safety threshold, the alternative plan is activated. For example, when direct migration is not feasible, the task is split into micro-task units and assigned to multiple devices, or the task execution accuracy is reduced to compress resource requirements. The verification results are fed back to the global scheduling module to dynamically update the policy template and calculation rules, such as disabling high-overhead migration paths or optimizing the timing of redundant copy generation, ultimately improving the system's adaptability in dynamic heterogeneous environments.

[0019] A multi-device collaborative control system for embedded real-time operating system deployment, comprising: The task link parsing module is used to build a real-time dependency graph and disassemble subtask link units; Dynamic priority scheduling module, used to implement the priority weight calculation model and two-way priority negotiation mechanism; Resource elastic adaptation module, used to manage virtual resource pools and generate resource adaptation policy templates; Real-time compensation module, used to deploy delay prediction agents and path switching strategies; The verification engine module is used to perform dual verification of offline simulation and online dynamic sandbox.

[0020] (3) Beneficial effects The present invention provides a multi-device collaborative control method for embedded real-time operating system deployment. It has the following beneficial effects: (1) This multi-device collaborative control method, applied to embedded real-time operating system deployments, effectively addresses the challenges of task priority conflicts and resource utilization imbalance in heterogeneous multi-device environments 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 requirements in real time, dynamically adjusting subtask weights and execution paths to ensure conflict-free delivery of end-to-end delay constraints. It also optimizes global resource utilization, avoiding device overload or idleness issues caused by traditional static scheduling.

[0021] (2) This multi-device collaborative control method, applied to embedded real-time operating system deployments, combines a cross-device real-time compensation algorithm with a dual verification mechanism to enhance the system's robustness and adaptability in dynamic disturbance scenarios. Through strategies such as pre-embedded redundant replicas, dynamic path switching, and secondary decomposition of task units, it can rapidly respond to device failures or resource changes, ensuring the real-time performance of core links. A dual verification framework of offline simulation and online sandboxing ensures the reliable implementation of scheduling strategies in complex environments, enabling highly reliable, low-latency multi-device collaborative control in fields such as industrial automation and the intelligent Internet of Things. BRIEF DESCRIPTION OF THE DRAWINGS

[0022] Figure 1 It is a schematic diagram of the overall framework of the present invention; Figure 2 This is a control logic timing diagram of the present invention. DETAILED DESCRIPTION

[0023] The following will clearly and completely describe the technical solutions in the embodiments of the present invention in conjunction with the accompanying drawings. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without making creative efforts are within the scope of protection of the present invention.

[0024] See also Figure 1 and Figure 2 The present invention provides a technical solution: a multi-device collaborative control method applied to embedded real-time operating system deployment, comprising the following steps: S1: Construct a real-time dependency graph for the task link, and decompose the multi-device collaborative task into sub-task link units that include execution paths, real-time constraint thresholds, and cross-device communication dependencies. When constructing the real-time dependency graph for the task link, first analyze the end-to-end real-time requirements of the task link based on 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.

[0025] Specifically, it includes: based on the mapping relationship between task type and device function, identifying the logical dependency hierarchy between subtasks. For example, in industrial automation scenarios, sensor data acquisition, control algorithm calculation, actuator action triggering and other links are divided into independent subtasks, and the latest completion time threshold of each subtask is marked; based on the heterogeneous characteristics of the equipment, cross-device communication dependencies are established. For example, if a subtask needs to forward data through a specific device, the communication interface type and transmission stability parameters are marked in its execution path; at the same time, the device status changes are dynamically monitored. When it is detected that the subtask cannot be executed on the original path, an alternative execution path is automatically generated and the real-time constraint threshold is recalculated; the heterogeneous characteristics of the equipment include computing power differences and communication protocol compatibility; the changes in the device status include sudden load surges or communication link interruptions. For example, when a subtask exceeds the communication delay limit due to overload of the target device, the system will select a migration path and update the real-time threshold of the subtask based on the resource idle status of the backup device and the matching degree of the communication interface to ensure that the end-to-end delay of the task link still meets the global requirements.

[0026] In addition, the rationality of the division of subtask link units is verified through sandbox simulation. If logical dependency conflicts or imbalanced real-time threshold distribution are found, the subtask granularity or dependency relationship is retroactively adjusted to ultimately generate a task link topology structure that can dynamically adapt to the status of heterogeneous devices.

[0027] S2: Dynamically calculate the priority weight of each subtask based on the end-to-end delay requirements of the subtask link unit, the device load status, and the stability of the communication link. During the dynamic calculation of the subtask priority weight, the system first collects the end-to-end delay requirements of the subtask link unit, the current load status of the target device, and the stability parameters of the communication link in real time. For the end-to-end delay requirement, based on the global real-time constraints of the task link, the latest completion time threshold of the subtask is broken down into delay allocation values ​​for each stage according to the execution path. For example, if the total delay threshold is 100ms and the subtask link contains three stages, the stage delay values ​​are dynamically allocated according to the execution order, such as 30ms, 40ms, and 30ms, and the allocation ratio is adjusted in real time based on fluctuations in the device load.

[0028] When it is detected that the current load of a device exceeds the preset threshold, such as the CPU usage rate is higher than 80%, the priority weight of the subtask to be executed on the device will be downgraded, and a load warning signal will be sent to the associated devices. If the stability parameters of the communication link, such as packet loss rate or delay jitter, exceed the acceptable range, an attenuation coefficient will be applied to the priority weight of the subtask that depends on the link. For example, the priority weight will be reduced by 10% for every 5% increase in packet loss rate.

[0029] For subtasks with multiple path choices, the system calculates the candidate priority weights for each path in parallel and selects the path that meets real-time constraints and has the most stable communication link as the execution plan. When a subtask cannot be executed along the original path due to a sudden device failure or communication interruption, the priority weight recalculation process is immediately triggered: based on the device load, communication stability, and remaining delay margin of the backup path, the priority weights are reallocated 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 it is found that the weight allocation causes device resource contention or real-time conflicts, the system goes back to the previous stable state and recalculates using a progressive weight correction algorithm.

[0030] S3: Through distributed resource probes, the system collects computing power, memory, and communication bandwidth data of heterogeneous devices in real time, generates resource adaptation strategy templates, decomposes tasks into lightweight execution units adapted to the capabilities of different devices, and dynamically allocates them to low-load devices. When implementing distributed resource probe collection and dynamic task allocation, the system periodically collects the target device's real-time computing power utilization, available memory capacity, and remaining communication bandwidth through lightweight resource probe modules deployed on each device, and aggregates the data into the global resource adaptation engine. For example, for computing power collection, the probe module estimates the current computing power remaining that can be allocated to new tasks based on the device CPU's thread utilization and task queue depth. For communication bandwidth, the system dynamically calculates bandwidth availability by monitoring the throughput and packet queuing delay of the device's network interface.

[0031] When generating a resource adaptation policy template, the system first normalizes heterogeneous resources based on device capability differences. For example, it maps the GPU acceleration capability of high-computing-power devices into virtual computing units, and quantifies the communication interface stability of low-power devices into bandwidth reliability coefficients. Based on this, a multi-dimensional resource adaptation score table is constructed.

[0032] Subsequently, the task is decomposed into lightweight execution units based on the resource requirement characteristics of the subtask link unit, such as computation-intensive, communication-intensive or memory-sensitive. For computation-intensive subtasks, they are preferentially decomposed into micro-batch processing units that can be processed in parallel. For communication-intensive subtasks, they are encapsulated into data packet groups with redundant checksums and marked with the minimum bandwidth requirement threshold.

[0033] During dynamic allocation, the system compares the resource requirements of lightweight execution units with the device resource adaptation score in real time. If it detects that the current load of the target device exceeds the safety threshold of its adaptation score, for example, if the computing power utilization of a device has reached 90% of the upper limit of the score table, it immediately suspends the allocation of new task units to it and initiates a resource migration decision: based on the resource margins and communication link quality of adjacent devices, it selects the candidate device with the highest score as the migration target, and calculates the additional delay loss caused by the migration. If the migration loss exceeds 20% of the subtask real-time constraint threshold, the migration is abandoned and the task execution unit is triggered to be split into finer-grained microtasks and redistributed.

[0034] In addition, when a sudden abnormality occurs in the device resource status, 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 backup path according to the resource snapshot in the most recent healthy state, ensuring the continuity of the task link.

[0035] S4: Delay prediction and compensation agents are embedded in key nodes of the task chain. Based on historical delay data and device status, end-to-end delay fluctuations are predicted, and redundant execution replicas or low-load path switching strategies are dynamically selected. When deploying delay prediction and compensation agents at key nodes of the task chain, the system first extracts delay characteristic data of each device based on historical task execution logs, including task processing time, cross-device communication transmission time, and the frequency of abnormal interruptions, and establishes a delay fluctuation prediction model. For example, for communication node devices, the average packet transmission delay and jitter range under different load conditions in the past 24 hours are calculated. Combined with the current device CPU usage, memory available capacity, and network interface queue depth, the fluctuation range of end-to-end delay in the next stage is predicted.

[0036] When the predicted delay exceeds the real-time constraint threshold of the subtask link, the system triggers the compensation strategy selection mechanism: if it is detected that the target device or communication path has redundant resources, such as idle computing power or spare bandwidth, redundant execution copies are generated and pre-distributed to the backup device, while the main path task continues to execute; if the redundant resources are insufficient or the cost of generating redundant copies is too high, such as occupying more than 30% of the device's available capacity, the low-load path switching strategy is initiated. Based on the real-time load status of the adjacent devices and the quality of the communication link, the migration path with the smallest delay increment is selected, and the priority weight and execution timing of the task link are simultaneously updated. For example, when the predicted delay of a control instruction transmission path reaches a threshold of 120%, the system prioritizes switching to a backup path with a load below 50% and a communication packet loss rate of less than 2%. If the backup path is unavailable, the redundant copies are used to execute in parallel on the two paths, and the path output that returns a valid result first is finally selected.

[0037] For scenarios with unpredictable delays caused by sudden device failures, such as physical damage to a communication interface, the compensation agent immediately interrupts the current task execution, rolls back to the last available subtask node based on the most recent health status snapshot, recalculates the priority allocation and path switching plan for the remaining links, and marks the faulty device as isolated.

[0038] In addition, after the compensation strategy is executed, the system replays the key segments of the task link through sandbox simulation to verify whether the compensated end-to-end delay meets the constraints. If there is still a deviation, the parameter weights of the delay prediction model are iteratively adjusted and the path switching cost evaluation logic is optimized.

[0039] 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 the online dynamic sandbox. When implementing offline simulation verification, the system first builds a virtualized heterogeneous device cluster consistent with the real environment to simulate the dynamic task requests and device state disturbances that may occur in multi-device collaboration scenarios. For example, randomly generated high-real-time task flows are injected into the simulation environment, and abnormal working conditions such as sudden surges in device load, intermittent interruptions in communication links, or instantaneous exhaustion of computing resources are simulated. The priority allocation and resource migration operations of task links are performed through the global scheduling model.

[0040] During the simulation, the system records the end-to-end latency data of each subtask link in real time and calculates the proportion of tasks that meet the real-time constraint threshold as the achievement rate indicator. If the achievement rate of low-computing edge nodes is found to be consistently below the preset threshold of 80%, the system dynamically adjusts the attenuation factor parameters in the priority weight calculation model and adjusts the allocation weights of the resource load balancing gradient algorithm. For example, this can reduce the task allocation density of high-load devices or increase the priority compensation value of redundant paths. For priority conflicts exposed in the simulation, such as multiple subtasks competing for the same device resources, the system backtracks the logical dependencies of the task links, locally adjusts the subtask granularity through sandbox simulation, or introduces asynchronous execution windows to iteratively optimize the scheduling strategy.

[0041] It should be further explained that during the online dynamic sandbox verification phase, the system captures representative task chain execution fragments from a real-world environment, such as the sensor-controller-actuator closed-loop in industrial control scenarios, and reproduces their resource states and real-time constraints in the sandbox. During verification, resource mutation events are actively injected, such as simulating a sudden memory depletion on a device or a 50% drop in communication bandwidth, to trigger resource migration path switching and the execution of compensation strategies. For example, when a subtask cannot continue due to insufficient memory on the target device, the sandbox selects a neighboring low-load device as the migration target based on the resource elasticity awareness matrix and calculates the additional communication delay caused by the migration. If the delay increment exceeds 30% of the remaining time margin of the subtask, the migration is abandoned and the task unit is re-decomposed into finer-grained microtasks for redistribution. Simultaneously, the sandbox monitors the resource overhead of the compensation strategy, such as the computing power consumed by redundant replicas or the bandwidth consumed during the migration process. If the overhead exceeds a preset safety threshold, for example, if the overhead exceeds 15% of the total resource usage, the strategy is marked as high-risk and an alternative strategy is triggered. After verification, the system feeds back the sandbox operation results to the global scheduling module, dynamically updating the resource adaptation policy template and priority weight calculation rules, such as disabling high-overhead migration paths or optimizing the timing of generating redundant copies; among them, the sandbox operation results include the migration path feasibility score and the compensation policy overhead ratio.

[0042] Dynamically calculate the priority weight of each subtask including: Based on the real-time attenuation factor and resource occupancy feedback coefficient, a priority weight calculation model for subtask links is established; 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 device receiving the request adaptively adjusts the priority weight and execution timing of the local subtask based on the current resource status and the global requirements of the task link.

[0043] It should be further explained that, during the specific implementation process, when dynamically calculating the priority weights of subtasks, the system first establishes a correlation model between the real-time attenuation factor and the resource occupancy feedback coefficient for each subtask link unit. The real-time attenuation factor is dynamically calculated based on the interface type stability parameters 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 real-time attenuation factor is initially set to 1.2 and dynamically adjusted based on the current signal strength. The interface type stability parameters include the packet loss rate and delay fluctuations of Ethernet, CAN bus, or wireless modules. The resource occupancy feedback coefficient is generated based on the real-time load status of the target device. For example, when the device CPU utilization is higher than 75%, the resource occupancy feedback coefficient increases linearly, up to a maximum of 1.5. The real-time load status includes CPU utilization, memory utilization, and task queue length.

[0044] When it is detected that the calculated result of the priority weight of a subtask is lower than the minimum threshold corresponding to its end-to-end delay requirement, for example, the weight of the control instruction subtask needs to be ≥0.8 to meet the 50ms delay constraint, but the actual calculated value is 0.6, the system sends a priority compensation request to the associated devices that have a dependent relationship with the subtask through a two-way priority negotiation mechanism. The request carries the delay gap value of the current subtask, the device load status, and a list of optional migration paths.

[0045] The device receiving the request evaluates whether the priority weight of its associated subtask can be increased to compensate for the shortfall based on the real-time data of the local resource elasticity perception matrix. For example, after an executor device receives a compensation request, if its current load is less than 60% and there is sufficient communication bandwidth, the priority weight of the locally associated data processing subtask will be increased from 0.7 to 0.9, and the adjusted weight value and estimated execution completion time will be fed back to the global scheduling module. If the device load is too high or resources are insufficient, the request will be rejected and the resource restriction parameters will be returned, triggering the global scheduling module to reselect other associated devices or initiate task migration. The real-time data includes the available computing power margin, free memory blocks, and remaining communication bandwidth.

[0046] After the priority adjustment is completed, the system re-arranges the execution sequence of subtasks according to the new weight value, such as inserting the subtask with increased weight to the front of the device task queue and delaying the execution window of the low-weight subtask. In addition, when multiple associated devices initiate compensation requests at the same time, resulting in resource competition, the system arbitrates according to the real-time urgency of the task link: for example, in industrial control scenarios, the request of the emergency shutdown command link takes precedence over the regular data acquisition link, directly preempting the resource allocation authority of the target device. The task execution process after weight adjustment is verified through sandbox simulation. If it is found that a device is in load oscillation due to frequent response to compensation requests, such as CPU utilization fluctuating repeatedly between 70% and 90%, the weight smoothing algorithm is automatically enabled to limit the number of priority adjustments per unit time, and introduce the load change rate as a correction parameter for the feedback coefficient.

[0047] The generation of the real-time attenuation factor includes: Calculate the priority attenuation value of subtasks when transferring across devices based on the end-to-end delay requirement of the task link and the stability parameters of the device communication interface; When the priority attenuation value exceeds a preset threshold, a priority compensation request is triggered and broadcast to associated devices. It should be further explained that, during implementation, when constructing the real-time dependency graph for task links, the system defines the execution path of subtask link units based on the logical execution process and data dependencies of multi-device collaborative tasks. For example, in an industrial control scenario, sensor data acquisition, filtering processing, control algorithm operation, and actuator drive instruction issuance are broken down into sequentially executed subtask links, and each subtask is annotated 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 dependencies, the system identifies the device interaction interface type between subtasks and establishes a communication reliability score based on the interface protocol stability parameters; device interaction interface types include CAN bus, Ethernet, or wireless communication module; stability parameters include the CAN bus error frame rate and the wireless module signal strength. For example, if a subtask requires data transmission across devices via a wireless module, the communication stability coefficient of the link is dynamically calculated based on the historical communication success rate of 95% and the current signal strength of -70dBm, and is mapped to a real-time attenuation factor. When device heterogeneity leads to execution path conflicts, for example, a high-computing-power device cannot execute a specific subtask due to incompatible firmware versions, the system automatically traverses the device resource pool, selects a backup device with equivalent functionality and compatible interfaces, replans the subtask link topology, and updates the real-time constraint threshold: for example, after migrating the control algorithm task originally scheduled for the high-computing-power device to the backup device, due to its lower computing power, the real-time threshold of the subtask needs to be relaxed from 30ms to 40ms, and the execution window of the downstream subtask is compressed to maintain end-to-end latency. In addition, when a sudden change in device status is detected, such as a sudden failure of a communication interface, resulting in an interruption of the subtask link, the system traces back to the nearest recoverable node based on the real-time dependency graph, generates an alternative execution path, and redistributes real-time constraints, including: for example, when the controller-actuator link is interrupted, switching to the redundant controller path and dynamically adjusting the start time threshold of the actuator subtask based on the communication delay of the backup path.

[0048] The logical topology rationality of the subtask link is verified through sandbox simulation. If it is found that the real-time attenuation factor deviates from the actual performance of the device by more than 20%, the graph reconstruction process is triggered, including: redividing the subtask granularity or merging adjacent subtasks with low latency requirements to optimize the transmission efficiency of global real-time constraints.

[0049] The implementation of the two-way priority negotiation mechanism includes: The device receiving the priority compensation request reallocates the priority weights of local tasks based on the real-time data of the resource elasticity perception matrix; The adjusted priority weight is fed back to the task link global scheduling module, and the execution timing of the subtask link is updated.

[0050] It should be further explained that, in the specific implementation process, after receiving a priority compensation request, the device first parses the delay gap value and the list of optional migration paths in the request, and then performs a policy evaluation based on the real-time data of the local resource elasticity perception matrix. For example, when a controller device receives a request to increase the priority of a data processing subtask, the system verifies the computing power requirements associated with the subtask and the current remaining CPU capacity. If the remaining computing power is sufficient to cover the priority increase requested in the request, for example, increasing the weight from 0.7 to 0.9 requires an additional 15% of CPU resources, and the device currently has 20% remaining computing power, the local task queue is immediately adjusted to insert the subtask into the high-priority execution window, and the required memory blocks and communication bandwidth are pre-allocated. If the remaining computing power is only 5%, the migration path list is traversed to select a backup device with the smallest communication delay increment, such as an adjacent edge node. The subtask is split and partially migrated to this device. At the same time, the split execution plan and the adjusted real-time threshold are sent to the global scheduling module.

[0051] For subtasks that rely on multi-device collaboration, such as sensor-controller-actuator links, after adjusting local priorities, the device must simultaneously verify the resource readiness of downstream devices. For example, after the controller increases the priority of an algorithm, it must check the remaining capacity of the actuator device's command receiving 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 based on the global real-time level of the task link. Emergency safety tasks, such as device emergency stop commands, receive priority resource allocation, while regular tasks enter a waiting queue and are marked as interruptible.

[0052] After the adjustment is completed, the device will feed back the new priority weight, estimated execution time and resource usage change to the global module, triggering the status synchronization of the associated devices. For example, after completing the priority increase, an actuator device needs to notify the upstream controller to send data packets in advance to avoid waiting in vain, and at the same time update the task triggering conditions of the downstream status monitoring device. If the migration path fails due to a sudden communication failure, such as the backup device being offline, the device rolls back to the original priority configuration and triggers a global alarm to start the redundant link reconstruction process. The adjusted task execution flow is verified through sandbox simulation. If it is found that the priority increase causes the real-time performance of other subtasks to deteriorate, such as a data collection task that is delayed beyond the limit due to resource preemption, the weight balancing algorithm is enabled to dynamically release some resources to low-priority tasks while meeting the core link constraints.

[0053] The generation of a resource adaptation policy template includes: Abstract the computing power, memory, and communication bandwidth of heterogeneous devices into a dynamically mapped virtual resource pool; Through the resource load balancing gradient algorithm, lightweight execution units are dynamically allocated according to the real-time load status of the device, and real-time loss evaluation parameters of the resource migration path are generated.

[0054] It should be further explained that, in its implementation, when generating resource adaptation policy templates, the system first normalizes the computing power, memory, and communication bandwidth of heterogeneous devices. For example, it converts the parallel processing capability of a high-performance computing device's GPU into standard computing units and quantifies the stability of a low-power embedded device's communication interface into a bandwidth reliability rating. Based on this, a multi-dimensional resource adaptation score table is constructed. For devices with different resource types, such as compute-intensive nodes, high-memory nodes, or low-latency communication nodes, the system dynamically categorizes the resource requirements of lightweight execution units. For image processing tasks, these tasks are broken down into parallelizable micro-batches and labeled with GPU computing power requirements. For real-time control instructions, these tasks are encapsulated into timestamped data packets and set a maximum communication latency tolerance. During the dynamic allocation process, the system monitors changes in the target device's resource adaptation score in real time. If a device's computing power utilization exceeds the score table's safety threshold—for example, if the maximum computing power utilization allowed in the score table is 85% and currently reaches 90%—the system halts the allocation of compute-intensive task units to it and initiates resource migration decisions.

[0055] During migration, priority is given to candidate targets with the highest resource adaptation scores and qualified communication link quality among adjacent devices. For example, a task unit is migrated to an edge node with a computing power utilization rate below 70% and a communication packet loss rate below 1%. The additional delay loss caused by the 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 triggered to undergo a secondary decomposition: the original task is split into more fine-grained sub-modules. For example, an image processing task can be decomposed into regional blocks for processing, which are then distributed to multiple low-load devices for parallel execution. At the same time, the real-time threshold of each sub-module is adjusted to match the decomposed execution logic.

[0056] When a device experiences a sudden resource anomaly, such as memory overflow that causes task execution to fail, the system rolls back unfinished tasks to the most recent stable state based on the historical health snapshot of the resource elasticity perception matrix and reallocates them to backup path devices for execution. For example, if a data processing task is interrupted due to a memory anomaly on the target device, the system automatically switches to a backup device that was verified to be available three days ago and recalculates the startup delay compensation value for the task based on the current communication link quality.

[0057] Furthermore, for situations where communication bandwidth suddenly drops, such as when network congestion causes bandwidth to drop to 60% of the required value, the system dynamically activates data compression transmission mode, reducing the amount of data transmitted per transmission and increasing the transmission frequency to maintain overall data throughput. The system also updates the bandwidth reliability parameters in the resource adaptation score table. Sandbox simulations verify the effectiveness of resource migration paths. If the end-to-end latency after migration still exceeds the constraint threshold, the path is marked as a high-risk solution and a dynamic load balancing strategy is triggered, redistributing the task units to be migrated between adjacent devices based on the score ratio.

[0058] The real-time loss assessment parameters for resource migration paths are used to: When the device resource status suddenly changes, the execution of unfinished task units is interrupted; The priority weight is recalculated according to the real-time loss assessment parameter, and the mapping relationship of the virtual resource pool is updated after the task unit is migrated to the target device.

[0059] It should be further explained that, in the specific implementation process, when the resource elastic adaptation feedback loop is triggered, the system first monitors the sudden change of the device resource status in real time. For example, if the memory usage rate exceeds 95% or the communication bandwidth drops below 50% of the required value, the current task execution process of the affected device will be immediately interrupted, and the unfinished task units will be marked as pending migration. For example, when a data processing task is interrupted due to a sudden memory overflow on an edge computing node, the system freezes the context state of the task, including the pointer to the processed data block, the intermediate calculation results, and the buffer for data to be transmitted. Then, based on the real-time loss evaluation parameters of the resource migration path, such as the estimated communication delay for migrating to the backup device, the remaining computing power of the target device, and the time cost of restarting the task, a priority-weighted recalculation request is generated.

[0060] If the assessment finds that the delay loss of migrating to the preferred backup device exceeds 30% of the remaining time margin 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 abandon the direct migration and start the secondary decomposition of the task unit: split the original task into independently executable microtask modules, such as dividing the image recognition task into four sub-blocks by area, and assigning them to multiple low-load devices for parallel processing. At the same time, assign an independent real-time constraint threshold to each microtask module, such as the total delay threshold is split proportionally according to the number of sub-blocks.

[0061] When the target backup device has insufficient resources, such as when the available memory is lower than the minimum required by the microtask, the system traverses the list of adjacent devices 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 computing power surplus weight.

[0062] After the 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 lowering its resource adaptation score, while increasing the load factor of the target device to avoid over-allocation of subsequent tasks. For extreme scenarios where the migration path completely fails due to communication interruption, such as the standby device being offline, the system rolls back to the last available state based on the historical health snapshot, and simulates the local resource reconstruction plan in the sandbox, including: for example, isolating the faulty device and enabling redundant communication links, rebinding the task unit to the device on the redundant path for execution, and compressing the execution window of subsequent subtasks to compensate for the rollback time. In addition, when resource contention is detected during the execution of the migrated task, such as multiple microtasks competing for the GPU resources of the same device, the system dynamically adjusts the execution sequence according to the real-time urgency: urgent microtasks obtain resource locks first, non-critical tasks enter the polling waiting queue, and set a timeout interrupt mechanism. If the waiting time exceeds 20ms, a second migration is triggered.

[0063] After the migration is completed, the resource reallocation effect is verified through sandbox playback, including: if it is found that the end-to-end delay of a microtask exceeds the threshold due to multiple migrations, the adjacent microtasks are merged and reallocated to a single high-computing power device, and the device compatibility parameters in the resource elasticity perception matrix are updated at the same time.

[0064] The execution of the delay prediction and compensation agent includes: Redundant execution replicas are embedded in the communication nodes of the task link, and the end-to-end delay fluctuation range is predicted based on the device status; If the predicted delay exceeds the real-time constraint threshold, a redundant replica is started or a switch is made to a low-load path, and the compensation strategy with the lowest resource overhead is selected through the path switching cost evaluation function.

[0065] It should be further explained that, during the specific implementation, during the delay prediction and compensation agent execution process, the system pre-embeds redundant execution replicas at key nodes on the backup path based on the task link's historical execution logs and real-time device status data. For example, at the communication node where the controller sends control instructions to the actuator, two data copies are synchronously generated and cached in a temporary memory pool on adjacent edge devices. Simultaneously, the real-time communication quality of the primary path, such as packet transmission success rate and delay jitter, is monitored. When the prediction model detects that the end-to-end delay fluctuation of the primary path may exceed the real-time constraint threshold, for example, if the predicted delay reaches the threshold of 120% and the fluctuation amplitude continues to increase, the system selects the optimal compensation strategy based on the path switching cost evaluation function: If the primary path's communication stability score is higher than the backup path's (e.g., the primary path's packet loss rate is 2% and the backup path's is 5%), the redundant replica is prioritized for parallel transmission, and the execution of other replicas is terminated after the first valid result arrives. If the backup path's load score is significantly better than the primary path's (e.g., the backup path's device CPU utilization is below 40% while the primary path's is 80%), the system directly switches to the backup path and adjusts the priority weights of subsequent subtasks. In the event of a sudden communication interruption, such as when a device on the primary path goes offline, the compensation agent immediately activates the redundant replica execution process and dynamically adjusts task parameters based on the device capabilities of the backup path. For example, when the backup device has low computing power, the control algorithm's calculation accuracy is downgraded from floating-point to fixed-point to shorten processing time, while the data packet length is compressed to reduce communication time. If a redundant replica cannot be generated due to resource constraints, such as insufficient memory on the backup device, a dynamic path switching strategy is initiated: all reachable devices in the resource elasticity perception matrix are traversed, and the path with the smallest incremental communication delay is selected, such as migrating to a device with a 10ms increase in delay but a load below 50%. The startup time window of the downstream subtask is also updated simultaneously, such as adjusting the actuator response delay threshold from 20ms to 25ms.

[0066] After the compensation strategy is executed, the system verifies the actual improvement effect of end-to-end delay through sandbox playback: If the delay after compensation still exceeds the threshold by more than 5%, it triggers iterative optimization of the compensation strategy, such as increasing the number of redundant copies or shortening the path switching decision cycle; if the compensation leads to excessive resource overhead, such as redundant copies occupying 30% of the total bandwidth, it falls back to the baseline strategy and marks the scenario as a high-risk condition. Subsequently, secondary decomposition of task units will be preferred instead of compensation.

[0067] In addition, when a priority conflict caused by multi-path switching is detected, such as two backup paths responding simultaneously, resulting in duplicate data execution, the system arbitrates based on the globally unique identifier of the task link, retaining only the task flow that reaches a valid result first, and forcibly terminating other redundant processes to free up resources.

[0068] Offline simulation verification includes: Inject random task requests and device failure disturbances into a virtualized heterogeneous device cluster and calculate the real-time constraint achievement rate of the global scheduling model. The attenuation factor threshold in the priority weight calculation model and the allocation parameters of the resource load balancing gradient algorithm are dynamically modified according to the simulation results.

[0069] It's important to note that during offline simulation and verification, the system constructs a virtualized cluster consisting of heterogeneous device nodes, simulating the multi-device collaborative task execution environment found in real industrial scenarios. For example, the cluster deploys high-computing industrial computers, low-power edge nodes, and communication gateways, each configured with differentiated resource parameters. For example, the industrial computer is configured with 8 CPU cores and 16GB of memory, while the edge nodes are configured with 4 cores and 4GB of memory.

[0070] During the simulation, dynamic task flows are injected, including periodic control instructions, sudden data processing requests, and random device failure events. For example, a simulation of a CPU usage spike of 90% for 10 seconds at an edge node every 5 minutes is simulated. The system executes a global scheduling model, records the end-to-end latency data of each subtask link in real time, and calculates the proportion of tasks that meet real-time constraints as an achievement rate indicator. If the achievement rate of a certain device group continues to fall below a preset threshold, such as the achievement rate of a low-computing-power node group falling below 75%, the attenuation factor parameters of the priority weight calculation model are dynamically adjusted. For example, the priority attenuation coefficient of high-load devices is increased from 1.2 to 1.5 to reduce their task allocation density. At the same time, the allocation weights of the resource load balancing gradient algorithm are optimized. For example, the bandwidth margin weight is increased for communication-intensive tasks to reduce the impact of the computing power demand weight.

[0071] When the simulation detects a priority conflict, such as when multiple subtasks compete for the GPU resources of the same device, resulting in a queue blockage, the system backtracks the logical dependencies of the task chain and simulates local adjustment strategies through sandbox simulation: for example, the image processing task originally scheduled to be executed on a single device is split into two parallel subtasks, which are respectively assigned to the idle GPU units of adjacent devices, and asynchronous execution windows are set for them, such as subtask A is executed in 0-30ms and subtask B is executed in 10-40ms, to avoid resource contention. If the delay still exceeds the standard after the split, such as subtask A is 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 specific time window, and reserving a compensatory execution period for the interrupted tasks after preemption.

[0072] After the simulation, the system generates a model parameter correction plan based on the achievement rate distribution and conflict resolution records. For example, the weight of the communication link stability parameter is increased from 20% to 30%, and the number of subtasks that a single device can execute simultaneously is limited to no more than twice the number of its CPU cores. For extreme conditions exposed in the simulation, such as the simultaneous failure of three consecutive device nodes, the system marks them as high-risk scenarios and triggers an elastic resource pool expansion strategy: in subsequent scheduling, at least two backup device nodes are automatically reserved for critical mission links and allocated a minimum guaranteed resource quota, such as 10% of computing power and memory.

[0073] Through multiple rounds of iterative simulation verification, the system gradually converges to the optimal parameter combination, ensuring the robustness and real-time guarantee capabilities of the global scheduling model in a dynamic heterogeneous environment.

[0074] Online dynamic sandbox verification includes: Intercept the execution fragments of task links in real scenarios and simulate the switching process of resource migration paths; The sandbox verifies whether the additional resource overhead of the screening compensation strategy is lower than the preset threshold, and feeds back to the global scheduling module for strategy iterative optimization.

[0075] It should be further explained that during the specific implementation process, when implementing online dynamic sandbox verification, the system dynamically intercepts typical execution fragments of the task chain from the real operating environment, such as the complete chain from sensor data acquisition to motion command generation in the industrial robot arm control scenario, and reconstructs its execution environment in the sandbox, including device resource snapshots and real-time constraints. The device resource snapshot includes CPU occupancy, memory distribution, and communication bandwidth utilization. For example, for a certain closed-loop control chain, the sandbox accurately reproduces the current load of the controller device and the communication delay baseline of the actuator interface. It then actively injects resource mutation events, including simulating the sudden exhaustion of controller memory to 95% or the sudden drop of communication bandwidth to 40% of the original value, triggering the coordinated response of the resource elastic adaptation feedback loop and the delay compensation agent. When the sandbox detects the feasibility of the resource migration path, such as migrating unfinished data processing tasks to edge nodes with 40% remaining computing power and 50% idle memory, the additional delay loss and resource overhead caused by the migration are calculated in real time: if the migration delay increment exceeds 35% of the remaining time margin of the subtask, for example, the migration increases by 18ms when there are 50ms remaining, then the direct migration is abandoned and the task unit is started to decompose twice, splitting it into two micro-task modules, such as decomposing data processing into feature extraction and result aggregation, and assigning them to two low-load devices for parallel execution respectively, and setting independent real-time thresholds for each module, such as feature extraction must be completed within 25ms and aggregation must be completed within 15ms.

[0076] The sandbox also monitors the resource overhead of compensation strategies, such as the total memory usage of redundant copies or the peak bandwidth consumed during the migration process. If a strategy's total overhead exceeds a pre-set safety threshold, such as 25% of the system's total bandwidth, the strategy is flagged as high-risk and an alternative strategy is triggered. For example, redundant copy generation may be disabled, and task execution accuracy may be dynamically reduced, such as by reducing the number of control algorithm iterations from 100 to 80, to reduce resource requirements. After verification, the system feeds the sandbox results back to the global scheduling module, dynamically updating the device compatibility parameters and priority weight calculation rules in the resource adaptation strategy template. The sandbox results include the migration path score, compensation strategy effectiveness, and resource overhead ratio. For example, if a migration path fails three verifications in the sandbox due to excessive communication delay fluctuations, it is removed from the list of selectable paths in the resource elasticity awareness matrix, and the communication stability score of the associated device is reduced. If a compensation strategy maintains a resource overhead below 10% and a delay compliance rate exceeding 90% across five verifications, its priority is increased, and the path switching decision cycle is shortened to 50% of its original value. For extreme conditions, such as two consecutive failed migration attempts, the sandbox automatically generates emergency execution plans. These include bypassing the regular task decomposition process, directly enabling high-computing backup devices to take over the entire link task, and dynamically compressing the execution window of non-critical subtasks, such as relaxing the latency threshold for logging tasks from 50ms to 80ms, to ensure the real-time performance of the core link. Verification data is ultimately fed into an offline simulation model, which is used to iteratively optimize the robustness parameters and exception handling logic of the global scheduling algorithm.

[0077] A multi-device collaborative control system for embedded real-time operating system deployment, comprising: The task link parsing module is used to build a real-time dependency graph and disassemble subtask link units; Dynamic priority scheduling module, used to implement the priority weight calculation model and two-way priority negotiation mechanism; Resource elastic adaptation module, used to manage virtual resource pools and generate resource adaptation policy templates; Real-time compensation module, used to deploy delay prediction agents and path switching strategies; The verification engine module is used to perform dual verification of offline simulation and online dynamic sandbox.

[0078] Through the implementation of the above technical solutions, the system realizes the global dynamic coordination of task priorities and real-time constraints in a multi-device heterogeneous environment, solves the problems of resource utilization imbalance and real-time conflicts caused by local optimization in traditional methods, and significantly improves the reliability and efficiency of embedded real-time operating systems in multi-device collaboration scenarios.

[0079] Through a dynamic priority transfer mechanism and a distributed resource elasticity awareness model, the system effectively addresses the challenges of task priority conflicts and resource utilization imbalances in heterogeneous multi-device environments. The system can perceive device load, communication link stability, and task real-time requirements in real time, dynamically adjusting subtask weights and execution paths to ensure conflict-free delivery of end-to-end latency constraints. It also optimizes global resource utilization and avoids device overload or idleness caused by traditional static scheduling.

[0080] Combining a cross-device real-time compensation algorithm with a dual verification mechanism improves the system's robustness and adaptability in dynamic disturbance scenarios. Through strategies such as pre-embedded redundant replicas, dynamic path switching, and secondary decomposition of task units, it can quickly respond to device failures or resource changes, ensuring the real-time performance of core links. A dual verification framework of offline simulation and online sandboxing ensures the reliable implementation of scheduling strategies in complex environments, enabling highly reliable, low-latency multi-device collaborative control in fields such as industrial automation and the intelligent Internet of Things.

[0081] It should be noted that, in this document, relational terms such as first and second, etc., are used only to distinguish one entity or operation from another entity or operation, and do not necessarily require or imply any actual relationship or order between these entities or operations. Moreover, the terms "comprises," "comprising," or any other variations thereof are intended to cover non-exclusive inclusion, so that a process, method, article, or device comprising a series of elements includes not only those elements, but also other elements not explicitly listed, or elements inherent to such process, method, article, or device. In the absence of further limitations, an element defined by the phrase "comprising a ..." does not exclude the presence of additional identical elements in the process, method, article, or device comprising the element.

[0082] While embodiments of the present invention have been shown and described, it will be appreciated by those skilled in the art that various changes, modifications, substitutions, and variations may be made to these embodiments without departing from the principles and spirit of the invention, and that the scope of the invention is defined by the appended claims and their equivalents.

Claims

1. A multi-device collaborative control method for embedded real-time operating system deployment, characterized in that: The steps include: S1: Build a real-time dependency graph for the task chain, breaking down 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 delay requirements of the subtask link unit, the device load status, and the stability of the communication link; S3: Distributed resource probes collect real-time computing power, memory, and communication bandwidth data from heterogeneous devices to generate resource adaptation policy templates. This decomposes tasks into lightweight execution units adapted to different device capabilities and dynamically allocates them to low-load devices. S4: Delay prediction and compensation agents are embedded in key nodes of the task chain. They predict end-to-end delay fluctuations based on historical delay 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 the resource migration path and the additional resource overhead of the compensation strategy through online dynamic sandbox.

2. The multi-device collaborative control method for embedded real-time operating system deployment according to claim 1, characterized in that: The dynamic calculation of the priority weight of each subtask includes: Based on the real-time attenuation factor and resource occupancy feedback coefficient, a priority weight calculation model for subtask links is established; 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 device receiving the request adaptively adjusts the priority weight and execution timing of the local subtask based on the current resource status and the global requirements of the task link.

3. The multi-device collaborative control method for embedded real-time operating system deployment according to claim 2, characterized in that: The generation of the real-time attenuation factor includes: Calculate the priority attenuation value of subtasks when transferring across devices based on the end-to-end delay requirement of the task link and the stability parameters of the device communication interface; When the priority attenuation value exceeds a preset threshold, a priority compensation request is triggered and broadcast to associated devices.

4. The multi-device collaborative control method for embedded real-time operating system deployment according to claim 3, characterized in that: The execution of the bidirectional priority negotiation mechanism includes: The device receiving the priority compensation request reallocates the priority weights of local tasks based on the real-time data of the resource elasticity perception matrix; The adjusted priority weight is fed back to the task link global scheduling module, and the execution timing of the subtask link is updated.

5. 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 policy template includes: Abstract the computing power, memory, and communication bandwidth of heterogeneous devices into a dynamically mapped virtual resource pool; Through the resource load balancing gradient algorithm, lightweight execution units are dynamically allocated according to the real-time load status of the device, and real-time loss evaluation parameters of the resource migration path are generated.

6. The multi-device collaborative control method for embedded real-time operating system deployment according to claim 5, characterized in that: The real-time loss assessment parameters of the resource migration path are used to: When the device resource status suddenly changes, the execution of unfinished task units is interrupted; The priority weight is recalculated according to the real-time loss assessment parameter, and the mapping relationship of the virtual resource pool is updated after the task unit is migrated to the target device.

7. 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 replicas are embedded in the communication nodes of the task link, and the end-to-end delay fluctuation range is predicted based on the device status; If the predicted delay exceeds the real-time constraint threshold, a redundant replica is started or a switch is made to a low-load path, and the compensation strategy with the lowest resource overhead is selected through the path switching cost evaluation function.

8. 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 failure disturbances into a virtualized heterogeneous device cluster and calculate the real-time constraint achievement rate of the global scheduling model. The attenuation factor threshold in the priority weight calculation model and the allocation parameters of the resource load balancing gradient algorithm are dynamically modified according to the simulation results.

9. 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: Intercept the execution fragments of task links in real scenarios and simulate the switching process of resource migration paths; The sandbox verifies whether the additional resource overhead of the screening compensation strategy is lower than the preset threshold, and feeds back to the global scheduling module for strategy iterative optimization.

10. A multi-device collaborative control system applied to the deployment of an embedded real-time operating system, characterized in that: include: The task link parsing module is used to build a real-time dependency graph and disassemble subtask link units; Dynamic priority scheduling module, used to implement the priority weight calculation model and two-way priority negotiation mechanism; Resource elastic adaptation module, used to manage virtual resource pools and generate resource adaptation policy templates; Real-time compensation module, used to deploy delay prediction agents and path switching strategies; The verification engine module is used to perform dual verification of offline simulation and online dynamic sandbox.

Images