A Distributed Heterogeneous Collaborative Edge Computing System and Method Based on DDS
By using a DDS-based distributed heterogeneous collaborative edge computing system, the problems of inconsistent interfaces and duplicate task execution between heterogeneous devices are solved, enabling reliable task transmission and status tracking, and improving the continuity and real-time performance of industrial operations.
Patent Information
- Application Number
- CN202611302798.4
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2026-08-26
- Publication Date
- 2026-11-17
AI Technical Summary
In existing technologies, data interfaces and task statuses between heterogeneous devices in industrial settings are inconsistent. When multiple nodes subscribe to the same task topic, they are prone to repeated execution. Fixed unloading causes communication, queuing, and device copying, leading to timeouts. Furthermore, there is a lack of traceable rerouting and degradation mechanisms after a node loses connection or fails to execute.
A distributed heterogeneous collaborative edge computing system based on DDS is adopted. Through strongly typed topics, task lifecycle events and node status topics, task admission judgment, node selection and rerouting are realized. Combined with differentiated QoS configuration, reliable transmission and status tracking of tasks are ensured.
It enables unified access to equipment from different manufacturers, avoids duplicate task execution, reduces communication latency, improves operational continuity and result traceability, and adapts to the real-time requirements of industrial sites.
Smart Images

Figure CN123114750A_ABST
Abstract
Description
Technical Field
[0001] This invention belongs to the field of distributed heterogeneous edge computing technology, specifically relating to a distributed heterogeneous collaborative edge computing system and method based on Data Distribution Service (DDS). Background Technology
[0002] In industrial production lines, warehousing and logistics, energy equipment, and smart manufacturing units, industrial cameras, thermal imagers, vibration sensors, and controllers continuously generate images, time-series signals, and equipment status data. Uploading all raw data to a remote cloud for analysis is easily limited by external link bandwidth, network fluctuations, data compliance, and control response time. Therefore, industrial intelligence tasks are increasingly being performed at the edge, closer to the data source.
[0003] Edge devices are typically not homogeneous server clusters, but rather consist of various devices such as general-purpose CPU control boards, NPU inference boxes, GPU workstations, FPGA acquisition cards, and programmable logic controllers. CPUs are suitable for protocol processing, image decoding, data cleaning, and control logic, while NPUs or GPUs are suitable for executing deep learning models. If each application connects to different devices via sockets or remote procedure calls, numerous point-to-point interfaces will be created. Changing nodes, upgrading models, or adding new data sources requires modifying the programs on both communicating parties, resulting in high system coupling.
[0004] DDS is a data-centric publish-subscribe middleware for real-time and embedded systems. Publishers and subscribers exchange data around strongly typed topics and can configure QoS (Quality of Service) parameters such as reliability, historical depth, deadlines, liveness, and resource limits. DDS can reduce direct dependencies between communicating parties, but DDS primarily addresses data distribution and does not automatically convert industrial computing data into permissible, directed, and traceable heterogeneous tasks, nor does it perform business deadline determination, heterogeneous node selection, and fault degradation solely based on ordinary topic messages.
[0005] Existing edge offloading solutions often focus on cloud-edge resource allocation or abstract task scheduling algorithms, lacking close integration with industrial field data communication middleware, task lifecycle, and execution result tracking mechanisms. Especially in scenarios involving large-size images or tensor payloads, communication latency may exceed model inference latency. If the scheduler only compares the computing speed of the CPU and NPU, without considering serialization, network transmission, node queuing, device memory copying, and result return time, expired tasks that should be executed locally or discarded may continue to be sent to accelerated nodes, resulting in results that have lost their industrial control significance by the time they arrive.
[0006] Based on the above application scenarios, the existing technology has at least the following shortcomings:
[0007] (1) Different devices usually use their own data formats and calling interfaces. Task identifiers, model versions, input shapes, execution status and error information lack unified definitions, making it difficult to reuse across CPU, NPU, GPU or FPGA nodes.
[0008] (2) In the normal publish-subscribe mode, multiple heterogeneous nodes may receive and execute the same task simultaneously when subscribing to the same computing topic. If the target node field, content filtering, or partitioning mechanism is missing, the node selection made by the scheduler cannot be implemented as targeted distribution at the network layer or subscription layer.
[0009] (3) The reliable transmission of DDS only describes the delivery mechanism of data samples, and is not equivalent to the fact that the task has been received, queued, executed and returned within the business deadline by the application. Existing solutions usually lack reception confirmation, lifecycle events and execution phase timestamps.
[0010] (4) After a task is resent or a node is switched, the original node may return a delayed result. If there is no distribution round or attempt number, the system will have difficulty distinguishing between the old and new execution results, and there is a risk that the old result will overwrite the new result or the execution mechanism will be triggered by mistake.
[0011] (5) There is a lack of continuous joint estimation of communication, queuing, device copying and model execution latency, and the node state does not form a closed loop with task admission, rerouting and local degradation. Summary of the Invention
[0012] The purpose of this invention is to overcome the shortcomings of the prior art and provide a distributed heterogeneous collaborative edge computing system, method, device and medium based on DDS. This invention addresses the problems in industrial settings where heterogeneous devices such as CPUs and NPUs are independent of each other, data interfaces and task states are inconsistent; multiple nodes subscribing to the same task topic can easily lead to duplicate execution; fixed unloading can easily cause timeouts due to communication, queuing and device copying; and there is a lack of traceable rerouting and degradation mechanisms after a node loses connection or fails to execute.
[0013] Firstly, the purpose of this invention is to provide a distributed heterogeneous collaborative edge computing system based on DDS, including a CPU edge node, a DDS data bus, at least one heterogeneous acceleration node, a collaborative control module, and a status and tracking module.
[0014] The DDS data bus carries strongly typed topics defined using an interface definition language. These strongly typed topics include at least a computation task topic, a computation result topic, and a node status topic. The computation task topic carries computation tasks and includes at least a task identifier, business deadline, target node identifier, distribution round, model identifier, data description information, and data payload. The computation result topic carries task lifecycle events and execution results and includes at least a task identifier, distribution round, execution node identifier, event type, stage timestamp, status code, and result data.
[0015] The node status topic is used to carry the running status of each heterogeneous acceleration node with the node identifier as the key, and includes at least resource usage information, queue depth, model capability set, and health status.
[0016] The CPU edge node is used to acquire raw industrial data from industrial data sources and perform preprocessing, encapsulating it into a computing task that conforms to the computing task theme format.
[0017] The heterogeneous acceleration node is used to filter the received computing tasks based on the target node identifier, only process computing tasks whose target node identifier matches its own node identifier, perform model inference, and publish lifecycle events and execution results through the computing result topic;
[0018] The collaborative control module is used to filter a set of candidate nodes that are model compatible and have valid states based on the information of the node status topic; jointly predict the total completion delay for each candidate node and the optional data representation method; compare the total completion delay with the remaining valid time of the task, perform task admission judgment, select the target node and data representation method that meet the business deadline requirements, and write the corresponding target node identifier and the current distribution round into the calculation task; when a node failure, task confirmation timeout, or prediction task timeout is detected, the collaborative control module increments the distribution round and performs task rerouting or local degradation processing;
[0019] The status and tracking module is used to record timestamps and event information at each stage of the task's entire lifecycle, using the task identifier and distribution round as the association key, and to update the latency prediction model and node health evaluation at each stage.
[0020] Furthermore, a preferred solution is provided: the computation task topic, computation result topic, and node status topic are configured with differentiated quality of service parameters.
[0021] The computing task topic is configured with reliable transmission, volatile persistence, a historical strategy of retaining a limited number of recent samples, and an asynchronous release method, and is configured with a sample lifecycle limit associated with the business deadline;
[0022] The calculation results are configured with a historical strategy that ensures reliable transmission, volatile persistence, and retention of no less than the number of events corresponding to the in-transit tasks.
[0023] The node state topic is configured with a best-effort transmission, volatile persistence, and a historical strategy that retains only the latest single sample. It is also configured with a node liveness detection and state update cycle detection mechanism.
[0024] Furthermore, a preferred solution is provided: the heterogeneous acceleration node subscribes to the computing task topic through a content filtering subscription method, using its own node identifier as a filtering condition, and only receives computing tasks whose target node identifier matches its own node identifier; or the target node identifier is verified at the application layer of the receiving end to filter out non-target tasks.
[0025] Furthermore, a preferred solution is provided: the total completion time includes data conversion, serialization, communication transmission, queuing, device memory copying, model execution, and result return.
[0026] Furthermore, a preferred solution is provided: when rerouting a task, the task identifier remains unchanged and the distribution rounds are incremented; the status and tracking module only outputs the results that match the current valid distribution round and whose arrival time is no later than the business deadline as valid results to the industrial execution agency, and the late results of the old rounds are only used for log recording and performance statistics.
[0027] Furthermore, a preferred solution is provided: when there are no candidate heterogeneous nodes that meet the business deadline, the collaborative control module performs at least one of the following degradation processes according to the task security level: calling the local lightweight model of the CPU edge node to perform inference, outputting conservative control instructions, and discarding expired tasks.
[0028] Furthermore, a preferred solution is provided: each heterogeneous acceleration node maintains a model capability table, which records the executable model identifier, version, input shape, data type, supported data representation methods, and estimated service latency; the collaborative control module filters candidate nodes that are compatible with the current computing task based on the model capability table.
[0029] Secondly, the purpose of this invention is to propose a DDS-based distributed heterogeneous collaborative edge computing method, applicable to any one or more of the above-mentioned DDS-based distributed heterogeneous collaborative edge computing systems, comprising the following steps:
[0030] S1: The CPU edge node collects raw industrial data and performs preprocessing to generate a computing task containing task identifier, business deadline, model identifier and data payload;
[0031] S2: Obtain the node status information published by each heterogeneous acceleration node, and filter the candidate node set based on model compatibility, health status and status validity period;
[0032] S3: Jointly predict the total completion delay for each candidate node and the available data representation methods;
[0033] S4: Compare the total completion delay with the remaining valid time of the task to determine whether the task is eligible for admission; if there is a solution that meets the business deadline, select the target node and data representation method, write the target node identifier and the current distribution round for the calculation task, and publish it through the DDS calculation task topic; if there is no feasible solution, perform local degradation or task discarding.
[0034] S5: The target heterogeneous acceleration node receives and verifies the computation task, publishes a receipt confirmation event, adds the task to the execution queue and completes model inference, and publishes lifecycle events and final execution results at each stage through the DDS computation result topic;
[0035] S6: Verify the validity of the returned result based on the task identifier and the current distribution round, and output the valid result to the industrial actuator;
[0036] S7: Update the latency statistics of each stage using the stage timestamps of the entire task lifecycle, and update the node health using node running events and fault recovery records for subsequent task decisions.
[0037] Thirdly, the present invention aims to provide a computer device, the computer device including a memory and a processor, the memory storing a computer program, and when the processor runs the computer program stored in the memory, the processor executes the DDS-based distributed heterogeneous collaborative edge computing method.
[0038] Fourthly, the present invention aims to provide a computer-readable storage medium for storing a computer program that executes the DDS-based distributed heterogeneous collaborative edge computing method.
[0039] Compared with the prior art, the advantages of the present invention are:
[0040] (1) This invention uses a strongly typed task, result and node status data model to unify the access of CPU, NPU, GPU and FPGA nodes from different manufacturers and with different processor architectures, thereby reducing point-to-point interface coupling.
[0041] (2) The present invention implements the node selection result as targeted distribution through target_node_id, content filtering subscription or partitioning mechanism, so as to avoid multiple subscription nodes repeatedly performing the same task.
[0042] (3) This invention directly writes the business deadline into the computing task and incorporates preprocessing, serialization, communication, queuing, device copying, model execution and result return into the prediction, reducing the invalid offloading of "accelerator is fast but the result is still late".
[0043] (4) The present invention makes joint selection among representations such as original image, compressed image, quantized tensor and intermediate features, so that representation conversion overhead and network transmission overhead participate in node selection.
[0044] (5) Differentiated QoS is adopted for tasks, results and status, taking into account the reliable delivery of key data, low overhead of status data and cleaning of expired samples, so as to reduce the interference of heavy load tasks on status updates.
[0045] (6) This invention achieves full-process tracking through task_id, dispatch_epoch, lifecycle events, status codes and stage timestamps, which can isolate late results from old rounds and locate problems in communication, queuing, execution or return stages.
[0046] (7) The present invention identifies nodes as disconnected or service abnormal by checking node status validity period, liveliness and receiving confirmation, and performs rerouting, local CPU degradation, conservative handling or discarding of expired nodes according to the remaining deadline, thereby improving operational continuity.
[0047] (8) Publishers and subscribers are automatically discovered in the DDS data space. When adding or replacing heterogeneous nodes, it is not necessary to rebuild all point-to-point connections, which facilitates production line expansion.
[0048] (9) Admission, historical depth and cleanup strategy are driven by the actual validity period of the task to avoid expired tasks from continuing to occupy network, queue and accelerator resources.
[0049] This invention is applicable to industrial visual quality inspection, robot vision, production line anomaly detection, equipment status diagnosis, thermal imaging analysis, and edge multi-sensor intelligent processing scenarios. Attached Figure Description
[0050] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on the structures shown in these drawings without creative effort.
[0051] Figure 1 This is a schematic diagram of the overall architecture of a distributed heterogeneous collaborative edge computing system based on DDS.
[0052] Figure 2A diagram illustrating DDS topic segmentation and differentiated QoS configuration;
[0053] Figure 3 This is a schematic diagram illustrating the deployment of an embodiment of the present invention for industrial visual quality inspection scenarios;
[0054] Figure 4 This is a schematic diagram of the interface of the collaborative edge computing monitoring platform of the present invention. Detailed Implementation
[0055] In the following description, specific details such as particular system architectures and techniques are set forth for illustrative purposes and not for limitation, in order to provide a thorough understanding of the embodiments of this application. However, those skilled in the art will understand that this application can also be implemented in other embodiments without these specific details. In other instances, detailed descriptions of well-known systems, apparatuses, circuits, and methods are omitted so as not to obscure the description of this application with unnecessary detail.
[0056] The technical solutions in the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only a part of the embodiments of this application, and not all of them. Based on the embodiments in this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.
[0057] Many specific details are set forth in the following description in order to provide a full understanding of this application. However, this application may also be implemented in other ways different from those described herein. Those skilled in the art can make similar extensions without departing from the spirit of this application. Therefore, this application is not limited to the specific embodiments disclosed below.
[0058] Implementation Method 1
[0059] This embodiment proposes a distributed heterogeneous collaborative edge computing system based on DDS. The system unifies the modeling of industrial computing tasks, execution events, and node resource status, and uses task deadlines, communication costs, node queues, and heterogeneous execution costs together for task admission and computing node selection. At the same time, the system implements scheduling decisions as targeted distribution through target node fields and content filtering subscriptions, enabling CPU nodes and NPU, GPU, or FPGA nodes to work collaboratively without directly binding to each other's interfaces.
[0060] like Figure 1As shown, the system includes CPU edge nodes, a DDS data bus, at least one heterogeneous acceleration node, a collaborative control module, and a status and tracking module. Each module can be deployed on an independent device or partially merged. The DDS data bus is a logical data exchange space and does not require a central message broker.
[0061] CPU edge nodes are deployed close to the data source to receive raw data such as images, thermal imaging, vibration, current, sound, or equipment status from industrial data sources. They perform data acquisition, protocol parsing, decoding, verification, scaling, normalization, format conversion, and task encapsulation. CPU edge nodes can also be directly connected to PLCs or industrial control networks to receive task priorities, product locations, process cycles, and safety levels.
[0062] In an industrial vision implementation, the CPU edge node scales the camera image to the model input size, converts the BGR color order to RGB, normalizes it according to model parameters, and converts the HWC arrangement to the NCHW arrangement. HWC is a common image storage order of "height-width-channel," while NCHW is a model input order of "batch-channel-height-width." The CPU edge node then forms a computational task sample containing task metadata and a data payload.
[0063] The heterogeneous acceleration nodes include NPUs, GPUs, FPGAs, or other dedicated computing units, and run DDS participants and model execution services. Each node establishes a content filtering subscription based on its own node_id, and only puts tasks with target_node_id equal to its own node identifier or broadcast identifier into its local queue. In implementations where content filtering topics are not enabled, the subscriber performs the same target node verification after receiving a task but before enqueuing it. After receiving a task, the node first publishes a RECEIVED event, then completes host-to-device memory copy, model execution, device-to-host memory copy, and post-processing, and publishes subsequent lifecycle events and the final result through the result topic.
[0064] Each heterogeneous acceleration node maintains a model capability table, which records at least the executable model identifier, model version, input shape, data type, arrangement, supported data representations, device type, estimated service latency, maximum concurrency, and available device memory. The scheduling module only sends tasks to nodes whose model capabilities and input descriptions are compatible, avoiding invalid execution due to mismatches in model files, preprocessing methods, or input tensors.
[0065] The collaborative control module can run on CPU edge nodes or as an independent DDS participant. It receives node status and historical task records, generates a candidate node set, and performs task admission, node selection, data representation selection, in-transit task restrictions, and fault recovery. Each distribution writes `target_node_id` and `dispatch_epoch`; when a rerouting occurs, `dispatch_epoch` is incremented and the old route is invalidated. The collaborative control module does not centrally forward all DDS data; instead, it makes decisions about which computation path a task enters, what representation to use, and when to degrade.
[0066] The status and tracking module associates node status, task status, and stage timestamps with `task_id` and `dispatch_epoch`. Node status reflects current resources, queues, model capabilities, and health; task status includes at least `CREATED`, `ADMITTED`, `DISPATCHED`, `RECEIVED`, `QUEUED`, `RUNNING`, `COMPLETED`, `FAILED`, `TIMEOUT`, `DROPPED`, and `CANCELLED`. Result topics can carry intermediate events such as `RECEIVED` and `RUNNING`, as well as the final `COMPLETED` result. Stage timestamps are used to decompose the latency of preprocessing, serialization, DDS transmission, queuing, device copying, model execution, post-processing, and result return.
[0067] like Figure 2 As shown, the DDS data bus carries three core strongly typed topics, with at least three topics: computation task topic, computation result topic, and node status topic. Each topic uses the Interface Definition Language (IDL) to define a strongly typed structure, and publish and subscribe interfaces are generated through code generation tools to ensure data format consistency.
[0068] The computation task subject is used to distribute computation tasks from the scheduling side to the execution side. The core fields include: 64-bit globally unique task identifier, incremental sequence number in the data source, task generation timestamp, business deadline, task priority / security level, model identifier and version, target node identifier, distribution round, input shape parameters, data type and memory arrangement, data representation encoding method, payload length and checksum, tensor / raw data payload.
[0069] The computation result topic can simultaneously carry lifecycle events such as task reception, queuing, execution, and completion. Core fields include: corresponding task identifier and sequence number, execution node identifier, distribution round, event type, task reception time, enqueue time, inference start time, inference end time, result release time, status code / error code, error description information, and inference result payload.
[0070] The node status topic is used by each node to periodically publish its own running status. The node identifier is used as the instance key, and the core fields include: heartbeat sequence number, status generation timestamp, status validity period / lease expiration time, CPU and memory utilization, accelerator utilization, device temperature and power consumption, queue depth and estimated waiting time, task completion / discard / error statistics, model capability set, and health status classification.
[0071] The data structures for computation tasks, computation results, and node status are shown in Tables 1, 2, and 3, respectively.
[0072] Table 1 Data Structure for Computational Tasks
[0073]
[0074] Here, `deadline_time` is not the topic publishing cycle of the DDS middleware itself, but rather the effective deadline for the industrial computing task. The scheduling module compares it with the current time and the predicted completion delay to determine whether the task is worth sending. In implementations supporting Lifespan QoS, the sample lifetime can be set to no greater than the remaining effective time of the task, but the receiving end still needs to perform service deadline verification.
[0075] `target_node_id` is used to implement the node selection result into a targeted subscription; `dispatch_epoch` is used to identify the current valid execution round of the same task. When a task is rerouted, `task_id` remains unchanged and `dispatch_epoch` is incremented to ensure unified tracking and isolation of results from older rounds.
[0076] Table 2 Calculation Results Data Structure
[0077]
[0078] The same task can generate multiple lifecycle event samples, among which the COMPLETED event carries the final business result. The collaborative control module only receives the final result that matches the task_id, has a dispatch_epoch equal to the current valid round, and arrives no later than the deadline_time; other late or old round results are only logged and do not drive the execution mechanism.
[0079] Table 3 Node Status Data Structure
[0080]
[0081] Node status is continuously updated using node_id as the key. If DDS Liveliness becomes inactive, the status age exceeds a preset threshold, or the status has not been updated for several consecutive periods, the collaborative control module will change the node from a healthy state to a suspected or unavailable state and stop distributing new tasks to it.
[0082] Different topics have different business objectives. Computational tasks and results require reliable correlation, and node status emphasizes up-to-dateness; therefore, the same set of QoS cannot be simply used. The preferred configuration is shown in Table 4.
[0083] Table 4 Differentiated DDS QoS Configuration
[0084]
[0085] "Reliable" indicates that the middleware performs acknowledgments and retransmissions only when matching relationships, resource constraints, and connection conditions allow; "BestEffort" indicates that reliable retransmissions are not performed for individual lost samples; "Volatile" indicates that distribution is only made to currently online matching subscribers; "TransientLocal" indicates that the publisher can retain a certain history for later-joining subscribers; "KeepLast(n)" indicates that only the most recent n samples are saved. Asynchronous publishing means that the application thread can continue execution after handing over the samples to DDS, while the actual sharding and network transmission are completed by a background thread.
[0086] ContentFilteredTopic is used to filter tasks by target_node_id; Lifespan is used to limit the effective survival time of samples in DDS; Liveliness is used to determine whether participants or data writers are still alive; the Deadline of the node status topic represents the expected update cycle, which is different from the business deadline_time in the computation task.
[0087] The task history depth is related to the maximum number of tasks in transit allowed by the system. When a new task arrives and the number of tasks in transit or the queue reaches its limit, the scheduling module prioritizes clearing tasks that have exceeded the deadline_time. If there are no expired tasks, the lowest-value task is rejected based on priority, security level, task age, or configuration policy to prevent infinite queuing and expired tasks from continuing to occupy network and accelerator resources.
[0088] Furthermore, the collaborative control module can be deployed on a CPU edge node or as an independent DDS participant, and its core execution process is as follows:
[0089] For task i, the collaborative control module first generates a candidate node set based on model identifier, model version, input shape, data type, supported data representation, and node status. Candidate nodes must simultaneously satisfy the following conditions: model capability matching, not expired status, not unavailable health status, and queue not exceeding the limit. The candidate set can be represented as:
[0090] in, Let `j` be the maximum allowed age for a node's state. For each candidate node `j` and the allowed data representation `r`, first calculate the remaining effective time for the task:
[0091]
[0092] Predict the total completion delay of the task passing through this node and using this representation:
[0093]
[0094] in, For local preprocessing or to indicate conversion delay, For serialization latency, For task sending delay, Queuing delay for candidate nodes For the data copy latency between the host and the device, For model execution latency, To account for post-processing delay, Delay for returning results. It can be estimated based on the payload size, recent effective bandwidth, and fixed protocol overhead; The latency can be estimated based on queue_depth and recent average service latency, or by summing the predicted service latency of each task in the queue.
[0095] The predicted values for each stage are continuously updated based on the actual measurement time of the completed tasks, with an exponential weighting method being preferred:
[0096]
[0097] Where a is the update coefficient between 0 and 1. When The sum of the safety margin M and the safety margin M is not greater than When node j and representation r constitute a feasible solution, the collaborative control module can select the solution with the shortest prediction completion latency from the feasible solutions, or further select nodes with higher health, lower recent error rate, or lower energy consumption when the latency is similar. If no feasible solution exists, the system will proceed according to the task safety level, using a local CPU lightweight model, conservative control, waiting for subsequent samples, or discarding expired samples.
[0098] After selection, the collaborative control module writes the target node to `target_node_id`, the current distribution round to `dispatch_epoch`, and encapsulates the payload according to the selected representation. The target node subscribes to receive tasks through content filtering and should publish a `RECEIVED` event within the acknowledgment timeout `T_ack`; this acknowledgment is used to distinguish between DDS samples being sent and tasks being received by the application.
[0099] The collaborative control module triggers a recovery judgment when any of the following conditions are met: the node's Liveliness is inactive or its status times out; the task does not receive a RECEIVED event within T_ack; the node returns a REJECTED or FAILED event; the queue waiting continues to grow, causing the predicted completion time to exceed the business deadline; the task's final result has not been returned even after exceeding the deadline_time.
[0100] During recovery, the current route is first marked as invalid and dispatch_epoch is incremented. Then, faulty nodes are excluded from the candidate set, and nodes and data representations are reselected. If compressing the image or quantizing the tensor can reduce the total completion latency, and the target node has the corresponding decoding or dequantization capability, the representation can be switched and the route re-routed. If the remaining valid time is insufficient to complete the re-unloading, the local CPU backup model is executed, conservative control results are output, or expired tasks are discarded.
[0101] To prevent delayed results from causing side effects, the valid key for business results is determined by both the task_id and the current dispatch_epoch. Results from previous rounds of the same task, duplicate results, or results after the deadline are only entered into the log and performance statistics; they do not overwrite the current result or drive PLCs, robots, or other actuators. For result outputs with external control side effects, idempotent processing should be applied according to the task_id, meaning that the same valid task executes the control action only once.
[0102] Each anomaly and recovery process records the triggering cause, failed node, original distribution round, new distribution round, rerouting target, degradation method, recovery time, and final state. This record, along with the node state and stage timestamp, is used to update the node health and latency model.
[0103] The system described in this embodiment reduces the interference of heavy-load tasks on status and result messages by using differentiated DDS QoS, task lifecycle events, and distribution rounds. It also performs rerouting, data representation switching, local CPU degradation, conservative handling, or discarding of expired tasks when nodes lose connection, processes are abnormal, queues are overloaded, task reception times out, or tasks are about to time out. It also identifies and isolates late results from old rounds, thereby improving the real-time performance, continuity, and traceability of intelligent processing in industrial settings.
[0104] Implementation Method 2
[0105] This implementation proposes a distributed heterogeneous collaborative edge computing method based on DDS, including the following steps:
[0106] Step 1: The CPU edge node acquires raw data from industrial cameras or sensors and performs decoding, scaling, normalization, format conversion, or feature extraction based on the target model.
[0107] Step 2: Generate task_id, sequence_no, source_time, deadline_time, priority, and safety_level based on the industrial cycle time, control action window, or task strategy to form a strongly typed computing task.
[0108] Step 3: Subscribe to the state instances published by each heterogeneous node, and generate a set of candidate nodes based on the state validity period, health status, and model capabilities.
[0109] Step 4: For candidate nodes and allowed data representations, jointly calculate the latency of preprocessing, serialization, communication, queuing, device copying, model execution, postprocessing, and result return.
[0110] Step 5: Compare the predicted total latency with the remaining valid time of the task, and select the target node and data representation that meet the deadline; if no feasible solution exists, proceed to the local degradation, conservative handling or expired task discarding process.
[0111] Step 6: Write target_node_id and dispatch_epoch, and publish the task by calculating the task topic according to QoS of reliable, asynchronous, limited history depth and optional Lifespan.
[0112] Step 7: The target heterogeneous node receives the task through content filtering subscription, verifies the task fields and payload, publishes the RECEIVED event within the confirmation timeout period, and puts the task into the local queue.
[0113] Step 8: Heterogeneous nodes record the queuing, device copying, execution, and post-processing phase times, execute the model, and publish RUNNING, COMPLETED, or FAILED events through the calculation result topic.
[0114] Step 9: The CPU edge node receives the final result according to task_id and dispatch_epoch, verifies whether the result arrives before deadline_time, and outputs the judgment to the PLC, robot or host computer.
[0115] Step 10: If the node status fails, the confirmation timeout occurs, the execution fails, or the prediction cannot be completed on time, increment dispatch_epoch and perform rerouting, switching, local CPU degradation, or security measures.
[0116] Step 11: Update communication, queuing, copying, and model execution latency statistics using the full-process timestamp, and update node health using node status, error events, and recovery results for use in subsequent task decisions.
[0117] Implementation Method 3
[0118] This implementation method combines Figure 3 An industrial vision quality inspection flowchart, detailing the complete operation process of the system:
[0119] This implementation is applied to the product appearance quality inspection scenario of conveyor belt products. An industrial camera is installed above the conveyor belt, and the Phytium architecture CPU edge node is directly connected to the camera. Two Atlas NPU acceleration nodes are deployed on the same industrial switching network. The PLC controller provides the current product number, conveying speed, and arrival time of the rejection mechanism.
[0120] Step 1: The CPU edge node reads the JPEG or PNG image captured by the camera, scales it to 224×224 pixels, converts BGR to RGB, performs ImageNet normalization, and converts it to a 1×3×224×224 NCHW FP32 tensor. The task sample carries model_id=mobilenetv2-12, model_version, target_node_id=atlas-01, dispatch_epoch=0, width=224, height=224, channels=3, dtype=float3, layout=NCHW, representation=FP32_TENSOR, payload_size=602112, and a payload check value.
[0121] Step 2: The Atlas NPU node subscribes to the task topic using `target_node_id=atlas-01` as the filter condition. After receiving and verifying the task, it publishes a `RECEIVED` event. Then, it uses `AscendCL` to load the OM model, copies the task data to the NPU memory, executes the model, obtains the 1000-dimensional classification scores, and calculates the Top-5 results. The `COMPLED` event carries the `task_id`, `executor_node_id`, `dispatch_epoch`, reception time, queuing time, inference start and end times, transmission time, status code, and Top-5 categories and scores. The Phytium CPU node only receives the results of the current valid distribution round, associates them with the product number, and sends a pass, defect, or re-inspection instruction to the PLC.
[0122] Step 3: When no subscriber matching atlas-01 is found, the node status times out, the task confirmation times out, or the prediction completion time exceeds the culling action window, the CPU edge node stops sending tasks to that route. If there are still alternative nodes that meet the deadline, the route is re-routed after incrementing dispatch_epoch; otherwise, for high-security tasks, the CPU executes a lightweight backup model or issues a conservative culling instruction, while for ordinary statistical tasks, expired samples are discarded and the reason is recorded. Subsequent results from the old rounds returned by the original Atlas node no longer drive the PLC.
[0123] like Figure 4 As shown, the system can be equipped with a monitoring platform to display the complete process of task execution, the time consumed at each stage, the running status of nodes and baseline performance data in real time, and to help operation and maintenance personnel monitor the system's running status and locate performance bottlenecks.
[0124] The experimental projects upon which this invention is based include the Fast DDS communication program, CPU preprocessing client, AscendCLNPU inference server, IDL type definition, unified experimental configuration, and test results. The currently verified and fixed basic link of "Phytium CPU preprocessing—DDS task transmission—Atlas NPU inference—DDS result return," as well as the associated records of task identifiers and stage timestamps, are included. Multi-node dynamic selection, target_node_id content filtering, continuous status topic publishing, dispatch_epoch rerouting, and the CPU backup model are extended implementations based on this basic link, and can be verified further by adding similar or different types of acceleration nodes.
[0125] Table 5 Implementation Environment Hardware and Software Configuration Table
[0126]
[0127] Table 6. Model Parameters, QoS Strategy, and Performance Experiment Results
[0128]
[0129] The above results demonstrate that the system can complete closed-loop transmission of strongly typed large tensor tasks and small result messages between two heterogeneous ARM64 devices, and can associate the execution process with task identifiers and stage timestamps. The round-trip latency of the large message DDS Ping / Pong is significantly higher than the execution latency of the Atlas local model, indicating that heterogeneous collaboration cannot solely rely on accelerator computing speed to determine whether to offload tasks; it also requires joint consideration of communication, queuing, data representation, device copying, and service deadlines. The return payload of the end-to-end link example differs from that of the large message Ping / Pong; the relevant data is used to demonstrate the functionality of the link and latency decomposition mechanism and is not used for direct performance comparison between the two sets of tests.
[0130] It is understood that the present invention has been described through some embodiments, and those skilled in the art will recognize that various changes or equivalent substitutions can be made to these features and embodiments without departing from the spirit and scope of the invention. Furthermore, under the teachings of the present invention, these features and embodiments can be modified to adapt to specific situations and materials without departing from the spirit and scope of the invention. Therefore, the present invention is not limited to the specific embodiments disclosed herein, and all embodiments falling within the scope of the claims of this application are within the protection scope of the present invention.
Claims
1. A distributed heterogeneous collaborative edge computing system based on DDS, characterized in that, It includes a CPU edge node, a DDS data bus, at least one heterogeneous acceleration node, a collaborative control module, and a status and tracking module; The DDS data bus carries strongly typed topics defined using an interface definition language. These strongly typed topics include at least a computation task topic, a computation result topic, and a node status topic. The computation task topic carries computation tasks and includes at least a task identifier, business deadline, target node identifier, distribution round, model identifier, data description information, and data payload. The computation result topic carries task lifecycle events and execution results and includes at least a task identifier, distribution round, execution node identifier, event type, stage timestamp, status code, and result data. The node status topic is used to carry the running status of each heterogeneous acceleration node with the node identifier as the key, and includes at least resource usage information, queue depth, model capability set, and health status. The CPU edge node is used to acquire raw industrial data from industrial data sources and perform preprocessing, encapsulating it into a computing task that conforms to the computing task theme format. The heterogeneous acceleration node is used to filter the received computing tasks based on the target node identifier, only process computing tasks whose target node identifier matches its own node identifier, perform model inference, and publish lifecycle events and execution results through the computing result topic; The collaborative control module is used to filter out a set of candidate nodes that are model compatible and have valid states based on the information of the node state topic; and jointly predict the total completion delay for each candidate node and the optional data representation method. The total completion delay is compared with the remaining valid time of the task. The task admission judgment is performed, and the target node and data representation method that meet the business deadline requirements are selected. The corresponding target node identifier and the current distribution round are written into the calculation task. When a node failure, task confirmation timeout or predicted task timeout is detected, the collaborative control module increments the distribution round and performs task rerouting or local degradation processing. The status and tracking module is used to record timestamps and event information at each stage of the task's entire lifecycle, using the task identifier and distribution round as the association key, and to update the latency prediction model and node health evaluation at each stage.
2. The distributed heterogeneous collaborative edge computing system based on DDS according to claim 1, characterized in that, The computation task topic, computation result topic, and node status topic are configured with differentiated quality of service parameters: The computing task topic is configured with reliable transmission, volatile persistence, a historical strategy of retaining a limited number of recent samples, and an asynchronous release method, and is configured with a sample lifecycle limit associated with the business deadline; The calculation results are configured with a historical strategy that ensures reliable transmission, volatile persistence, and retention of no less than the number of events corresponding to the in-transit tasks. The node state topic is configured with a best-effort transmission, volatile persistence, and a historical strategy that retains only the latest single sample. It is also configured with a node liveness detection and state update cycle detection mechanism.
3. The distributed heterogeneous collaborative edge computing system based on DDS according to claim 1, characterized in that, The heterogeneous acceleration nodes subscribe to the computing task topics through a content filtering subscription method, using their own node identifier as a filtering condition, and only receive computing tasks whose target node identifier matches their own node identifier. Alternatively, target node identifier verification can be performed at the application layer of the receiving end to filter out non-target tasks.
4. The distributed heterogeneous collaborative edge computing system based on DDS according to claim 1, characterized in that, The total completion time includes data conversion, serialization, communication transmission, queuing, device memory copying, model execution, and result return.
5. The distributed heterogeneous collaborative edge computing system based on DDS according to claim 1, characterized in that, When rerouting a task, the task identifier remains unchanged and the distribution round is incremented. The status and tracking module only outputs the results that match the current valid distribution round and whose arrival time is not later than the business deadline as valid results to the industrial execution agency. The late results of the old round are only used for log recording and performance statistics.
6. The distributed heterogeneous collaborative edge computing system based on DDS according to claim 1, characterized in that, When no candidate heterogeneous node meets the business deadline, the collaborative control module performs at least one of the following degradation processes based on the task security level: calling the local lightweight model of the CPU edge node to perform inference, outputting conservative control instructions, and discarding expired tasks.
7. The distributed heterogeneous collaborative edge computing system based on DDS according to claim 1, characterized in that, Each heterogeneous acceleration node maintains a model capability table, which records the executable model identifier, version, input shape, data type, supported data representation methods, and estimated service latency; the collaborative control module filters candidate nodes that are compatible with the current computing task based on the model capability table.
8. A distributed heterogeneous collaborative edge computing method based on DDS, characterized in that, The distributed heterogeneous collaborative edge computing system based on DDS, as described in any one of claims 1-7, comprises the following steps: S1: The CPU edge node collects raw industrial data and performs preprocessing to generate a computing task containing task identifier, business deadline, model identifier and data payload; S2: Obtain the node status information published by each heterogeneous acceleration node, and filter the candidate node set based on model compatibility, health status and status validity period; S3: Jointly predict the total completion delay for each candidate node and the available data representation methods; S4: Compare the total completion delay with the remaining valid time of the task to determine whether the task is eligible for admission; if there is a solution that meets the business deadline, select the target node and data representation method, write the target node identifier and the current distribution round for the calculation task, and publish it through the DDS calculation task topic; if there is no feasible solution, perform local degradation or task discarding. S5: The target heterogeneous acceleration node receives and verifies the computation task, publishes a receipt confirmation event, adds the task to the execution queue and completes model inference, and publishes lifecycle events and final execution results at each stage through the DDS computation result topic; S6: Verify the validity of the returned result based on the task identifier and the current distribution round, and output the valid result to the industrial actuator; S7: Update the latency statistics of each stage using the stage timestamps of the entire task lifecycle, and update the node health using node running events and fault recovery records for subsequent task decisions.
9. A computer device, characterized in that, The computer device includes a memory and a processor. The memory stores a computer program. When the processor runs the computer program stored in the memory, the processor executes the distributed heterogeneous collaborative edge computing method based on DDS according to claim 8.
10. A computer-readable storage medium, characterized in that, The computer-readable storage medium is used to store a computer program that executes the DDS-based distributed heterogeneous collaborative edge computing method of claim 8.
