Internet of Things data processing method, device and equipment and readable storage medium

Abstract

The invention discloses an Internet of Things data processing method, device and equipment and a readable storage medium, and is applied to the technical field of computers, and the method comprises the steps: obtaining a calculation request initiated by an Internet of Things application end, splitting the calculation request into a plurality of tasks, and analyzing a dependency relationship between the tasks; analyzing the characteristics of each task, and distributing each task to a target acceleration engine for task processing based on the characteristics and the dependency relationship; the target acceleration engine is a calculation acceleration engine or a logic acceleration engine; and after all the tasks are processed, feeding back a processing result to the application end of the Internet of Things. According to the method, fine management and cooperative processing of tasks can be realized, and low efficiency of overall request processing in a traditional mode is avoided; accurate scheduling of special tasks processed by a special engine can be realized, and resource waste is reduced; through a combined strategy of task splitting, dependence cooperation and accurate distribution, the overall data processing efficiency can be improved, and the adaptability to high-concurrency and large-flow Internet of Things scenes is enhanced.

Description

Technical Field

[0001] This invention relates to the field of computer technology, and in particular to an Internet of Things (IoT) data processing method, apparatus, device, and readable storage medium. Background Technology

[0002] With the rapid development of Internet of Things (IoT) technology, the number of terminal devices has exploded, from smart homes and smart cities to the industrial internet and the internet of vehicles. This massive number of devices generates massive amounts of data, which are typically characterized by high concurrency, high traffic, strong time-series requirements, and diverse structures. Traditional data processing architectures usually rely on servers centered around general-purpose CPUs (Central Processing Units) and relational or NoSQL (Not Only SQL) database software. However, in IoT scenarios, this traditional model faces severe challenges. For example, traditional models suffer from slow performance improvements, insufficient performance in high-concurrency scenarios, and weak data processing capabilities.

[0003] Therefore, improving the processing speed and performance of IoT data is a pressing technical problem that needs to be solved. Summary of the Invention

[0004] In view of this, the purpose of the present invention is to provide an Internet of Things (IoT) data processing method, apparatus, device and readable storage medium, which solves the problems of slow processing speed and poor data processing performance of IoT data in the prior art.

[0005] To address the aforementioned technical problems, this invention provides an Internet of Things (IoT) data processing method, comprising:

[0006] Obtain computing requests initiated by IoT application terminals, break down the computing requests into multiple tasks, and parse the dependencies between the tasks;

[0007] Analyze the characteristics of each task, and assign each task to a target acceleration engine for task processing based on the characteristics and the dependencies; the target acceleration engine is a computing acceleration engine or a logic acceleration engine.

[0008] Once all the tasks have been completed, the processing results will be fed back to the IoT application.

[0009] Optionally, the computation request initiated by the IoT application is obtained, the computation request is split into multiple tasks, and the dependencies between the tasks are resolved, including:

[0010] The computing request initiated by the IoT application is obtained, and the computing request is split according to a preset rule to obtain multiple tasks;

[0011] Static and dynamic analyses are performed on each task to obtain the explicit and implicit dependencies between them.

[0012] Each task is treated as a graph node, and the explicit and implicit dependencies are treated as directed edges. An adjacency list is used to construct a global task dependency graph that reflects the dependencies between the tasks.

[0013] Optionally, the characteristics of each task are analyzed, and each task is assigned to a target acceleration engine for task processing based on the characteristics and the dependencies, including:

[0014] Extract the general features and IoT metadata features of each task, and determine the target acceleration engine for each task based on the general features and IoT metadata features; the general features include at least computational density, parallelism factor, memory access form and data type flag; the IoT metadata features include at least data source, data priority and rule chain complexity.

[0015] Optionally, extract common features and IoT metadata features for each task, and determine the target acceleration engine for each task based on the common features and the IoT metadata features, including:

[0016] Extract the common features of each task and calculate the common feature values ​​of each common feature;

[0017] Based on the weighted method and each of the general feature values, the first tendency value corresponding to each of the tasks is calculated.

[0018] Tasks with a first tendency value greater than or equal to a first threshold are marked as computation acceleration tasks;

[0019] Tasks whose first tendency value is less than or equal to the second threshold are marked as logic acceleration tasks;

[0020] Tasks whose first tendency value is greater than the second threshold and less than the first threshold are designated as tasks to be labeled.

[0021] Extract the IoT metadata features of each of the tasks to be labeled, and calculate the metadata feature values ​​of each of the tasks to be labeled.

[0022] Based on the weighted method and the metadata feature values, the second tendency value corresponding to each of the tasks to be labeled is calculated;

[0023] Tasks with a second tendency value greater than or equal to the third threshold are marked as computation acceleration tasks;

[0024] Tasks whose second tendency value is less than the third threshold are marked as logic acceleration tasks;

[0025] Based on the dependencies in the global task dependency graph and the task's tag type, each task is assigned to the corresponding target acceleration engine for task processing.

[0026] Optionally, based on the dependencies in the global task dependency graph and the task's tag type, each task is assigned to a corresponding target acceleration engine for task processing, including:

[0027] When it is determined that the prerequisites of the task are satisfied based on the aforementioned dependency relationship, the task is added to the global ready queue.

[0028] The task is extracted from the global ready queue. If the task is marked as a computation acceleration task, the task is moved into the computation acceleration queue. If the task is marked as a logic acceleration task, the task is moved into the logic acceleration queue.

[0029] Monitor the real-time load status of the computing acceleration engine and the logic acceleration engine;

[0030] For the computing acceleration queue, a first target task is extracted from the computing acceleration queue according to a first preset priority and assigned to the computing acceleration engine with the lowest load;

[0031] For the logical acceleration queue, the second target task is extracted from the logical acceleration queue according to the second preset priority and assigned to the logical acceleration engine with the lowest load;

[0032] Once the first target task / second target task has been completed on the corresponding computing acceleration engine / logic acceleration engine, the status of the first target task / second target task will be updated to the completed status.

[0033] Trigger a pre-dependency check for subsequent tasks that depend on the task, and update the global ready queue based on the check results.

[0034] Optionally, trigger a pre-dependency check that depends on the task, and update the global ready queue based on the check result, including:

[0035] For all successor tasks of the task, update the state of the successor task in its predecessor dependencies;

[0036] Check whether all the prerequisites of each of the subsequent tasks are in a completed state;

[0037] If so, the subsequent task is added to the global ready queue.

[0038] Optionally, after all the tasks are completed, the processing results are fed back to the IoT application, including:

[0039] Obtain the execution results of all tasks corresponding to the computation request;

[0040] Based on the data relationships in the dependencies of the tasks, the execution results of each task are merged;

[0041] The merged execution results are formatted and redundant data is removed to generate a complete result set, which is then returned to the IoT application.

[0042] The present invention also provides an Internet of Things (IoT) data processing device, comprising:

[0043] The splitting and parsing module is used to obtain the computing request initiated by the IoT application, split the computing request into multiple tasks, and parse the dependency relationship between each task.

[0044] An analysis and allocation module is used to analyze the characteristics of each task and allocate each task to a target acceleration engine for task processing based on the characteristics and the dependencies; the target acceleration engine is a computing acceleration engine or a logic acceleration engine.

[0045] The feedback module is used to send the processing results back to the IoT application terminal after all the tasks have been processed.

[0046] The present invention also provides an Internet of Things (IoT) data processing device, comprising:

[0047] Memory, used to store computer programs;

[0048] A processor is used to implement the IoT data processing method described above when executing the computer program.

[0049] The present invention also provides a computer-readable storage medium storing computer-executable instructions, which, when loaded and executed by a processor, implement the IoT data processing method described above.

[0050] As can be seen, this invention obtains computing requests initiated by IoT application terminals, breaks down the computing requests into multiple tasks, and parses the dependencies between the tasks; analyzes the characteristics of each task, and assigns each task to a target acceleration engine for processing based on the characteristics and dependencies; the target acceleration engine is a computing acceleration engine or a logic acceleration engine; after all the tasks are processed, the processing results are fed back to the IoT application terminal. This invention, by breaking down computing requests into multiple tasks and parsing dependencies, enables refined management and collaborative processing of tasks, avoiding the inefficiency of overall request processing in traditional models; assigning tasks to matching target acceleration engines (computing acceleration engines or logic acceleration engines) based on task characteristics enables precise scheduling of dedicated engines processing dedicated tasks, reducing resource waste; through the combined strategy of task splitting, dependency collaboration, and precise allocation, overall data processing efficiency can be improved, enhancing adaptability to high-concurrency, high-traffic IoT scenarios.

[0051] In addition, the present invention also provides an Internet of Things (IoT) data processing device, equipment, and computer-readable storage medium, which also have the above-mentioned beneficial effects. Attached Figure Description

[0052] 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 embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on the provided drawings without creative effort.

[0053] Figure 1 A flowchart of an Internet of Things (IoT) data processing method provided in an embodiment of the present invention;

[0054] Figure 2 An architecture diagram of an IoT data processing acceleration system based on hardware and software integration is provided for an embodiment of the present invention;

[0055] Figure 3 A flowchart illustrating an IoT data processing acceleration method provided in an embodiment of the present invention;

[0056] Figure 4 This is a schematic diagram of the structure of an Internet of Things (IoT) data processing device provided in an embodiment of the present invention;

[0057] Figure 5 This is a schematic diagram of the structure of an Internet of Things (IoT) data processing device provided in an embodiment of the present invention. Detailed Implementation

[0058] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0059] With the rapid development of Internet of Things (IoT) technology, the number of terminal devices has exploded, from smart homes and smart cities to the industrial internet and connected vehicles. This massive number of devices generates massive amounts of data, which are typically characterized by high concurrency, high traffic, strong time-series requirements, and diverse structures. Traditional data processing architectures usually rely on servers with general-purpose CPUs at their core and relational or NoSQL database software. However, in IoT scenarios, this traditional model faces significant challenges.

[0060] First, traditional databases are optimized at the software level, such as by improving indexes, optimizing query plans, and adding caches. However, these optimizations gradually reach their performance bottlenecks under the pressure of high-concurrency writes and complex queries. As a general-purpose computing unit, the CPU's architecture suffers from problems such as low instruction execution efficiency, high context switching overhead, and memory walls when handling highly parallelized, data-intensive tasks, making it difficult to meet the extreme requirements of low latency and high throughput in IoT scenarios.

[0061] Secondly, some existing acceleration solutions also have shortcomings. For example, while GPUs have powerful parallel computing capabilities, they consume a lot of power, and their SIMT (Single Instruction, Multithreaded) architecture is more suitable for homogeneous large-scale parallel tasks in graphics rendering and scientific computing. For heterogeneous, pipelined tasks such as logical judgment, data filtering, and decompression commonly found in IoT data processing, their energy efficiency and flexibility are not optimal.

[0062] Furthermore, some manufacturers have attempted to accelerate applications using Application-Specific Integrated Circuits (ASICs). While these solutions offer extremely high performance, they suffer from long development cycles, high costs, and rigid algorithm logic, making them ill-suited for the rapid iteration and evolving algorithm models required by IoT services. They lack flexibility and versatility. On the other hand, hardware acceleration solutions using FPGAs offer both high performance and flexibility, but their development threshold is extremely high, requiring programming in hardware description languages ​​(such as Verilog or VHDL), which is difficult for software developers to master, thus limiting their widespread adoption.

[0063] Therefore, this invention provides a general solution that efficiently combines the hardware acceleration capabilities of FPGAs with the flexible control capabilities of CPUs, and provides a unified and easy-to-use programming interface for upper-layer applications. However, this solution fails to effectively address the access, scheduling, and collaborative operation of heterogeneous resources, thus hindering breakthroughs in the overall performance of IoT databases. This IoT data processing method overcomes the problems of slow performance improvement and insufficient performance in high-concurrency scenarios inherent in traditional methods, achieving a significant improvement in data processing performance.

[0064] Please refer to the details. Figure 1 , Figure 1 A flowchart illustrating an Internet of Things (IoT) data processing method provided in an embodiment of the present invention. The method may include:

[0065] S101: Obtain the computing request initiated by the IoT application, break down the computing request into multiple tasks, and resolve the dependencies between the tasks.

[0066] In this embodiment, the execution entity is an IoT data processing system. The IoT data processing system receives computing requests initiated by upper-layer IoT applications through a pre-defined API interface, breaks down and analyzes these requests, and determines the dependencies between tasks.

[0067] Furthermore, the aforementioned acquisition of computing requests initiated by the IoT application involves breaking down the computing requests into multiple tasks and resolving the dependencies between these tasks. Specifically, this may include:

[0068] Step 11: Obtain the computing request initiated by the IoT application, split the computing request based on preset rules, and obtain multiple tasks;

[0069] Step 12: Perform static and dynamic analysis on each task to obtain the explicit and implicit dependencies between tasks.

[0070] Step 13: Treat each task as a graph node, the explicit and implicit dependencies as directed edges, and use an adjacency list to construct a global task dependency graph that reflects the dependencies between tasks.

[0071] Specifically, when processing computing requests initiated by IoT applications, the system first breaks down the requests into multiple independent tasks according to preset rules, achieving fine-grained decomposition of complex requests. Then, static analysis clarifies the explicit dependencies between tasks based on the request's logical structure, while dynamic analysis uncovers implicit dependencies based on the system's real-time state, ensuring comprehensive task dependency identification. Finally, using tasks as graph nodes and the two types of dependencies as directed edges, an adjacency list is constructed to build a global task dependency graph, making task relationships clearly traceable. This process avoids the inefficiency caused by the failure to break down complex requests in traditional processing, and prevents task execution chaos caused by missing dependencies. Furthermore, the efficient storage method of the adjacency list facilitates rapid subsequent scheduling, laying a structured foundation for improving data processing efficiency in high-concurrency, high-traffic IoT scenarios.

[0072] S102: Analyze the characteristics of each task, and assign each task to the target acceleration engine for task processing based on the characteristics and dependencies; the target acceleration engine is either a computational acceleration engine or a logic acceleration engine.

[0073] Specifically, after task decomposition and dependency analysis, the characteristics of each task (such as computational complexity, density of logical rules, and data processing scale) are analyzed, and the dependencies between tasks are combined to accurately allocate tasks to suitable target acceleration engines. The logic acceleration engine runs on a general-purpose CPU, responsible for handling complex logic and branch-intensive tasks (such as protocol parsing and device scheduling); the computation acceleration engine runs on a heterogeneous FPGA computing card, specifically designed for handling tasks with high data parallelism, computational intensity, and latency sensitivity (such as face detection in video frames and data filtering). This targeted allocation method based on task characteristics and dependencies allows various tasks to execute efficiently on the most suitable hardware resources, while also avoiding task execution conflicts through dependency coordination, thereby fully leveraging the performance advantages of different acceleration engines and improving overall processing efficiency.

[0074] Furthermore, based on the above analysis of the characteristics of each task, and according to the characteristics and dependencies, each task is assigned to the target acceleration engine for task processing. Specifically, this may include:

[0075] Extract the general features and IoT metadata features of each task, and determine the target acceleration engine for each task based on the general features and IoT metadata features; the general features include at least computing density, parallelism factor, memory access form and data type flag; the IoT metadata features include at least data source, data priority and rule chain complexity.

[0076] Specifically, during the task allocation phase, two core characteristics of each task are extracted: Firstly, general characteristics reflecting common task processing needs, including computational density (measuring the intensity of numerical computation), parallelism factor (characterizing the task's ability to be split and executed in parallel), memory access format (evaluating memory access continuity and step size), and data type identifiers (clarifying data storage and processing formats), etc. Secondly, metadata characteristics tailored to the IoT scenario, including data source (locating data acquisition terminals or devices), data priority (defining the urgency of task processing), and rule chain complexity (reflecting the complexity of task logical relationships), etc. By comprehensively analyzing these two types of characteristics, a suitable target acceleration engine is matched for each task. For example, tasks with high computational density and large parallelism factor are preferentially allocated to the computational acceleration engine, while tasks with high rule chain complexity that require flexible processing based on data source and priority are allocated to the logic acceleration engine, achieving precise matching between tasks and engine capabilities and fully releasing hardware performance.

[0077] For example, the computation density N_d: N_d = 2 * (number of arithmetic and logical operation instructions / total number of instructions - 0.5), parallelism factor N_p: N_p = 2 * (number of iterations / parallelism - 0.5), memory access form N_m: N_m = 2 * (e^(-stride value / 64) - 0.5), data type flag N_t: N_t = 1 - (2 * double-precision operands / total floating-point operands), data source N_s: N_s (preset value, range [-1, 1], the higher the value, the more likely it is to contain computationally intensive tasks (such as images, videos, etc.)), data priority N_q: N_q = 2 * ((QOS level + 1) / SUM(QOS level) - 0.5), rule chain complexity N_r: N_r = 2 * (min(number of operators / 10, 1.0) - 0.5). Where stride is the step size; QOS is Quality of Service management.

[0078] Furthermore, the above-mentioned extraction of general features and IoT metadata features of each task, and determination of the target acceleration engine for each task based on the general features and IoT metadata features, may specifically include: extracting general features of each task and calculating each general feature value; calculating a first tendency value corresponding to each task based on a weighted method and each general feature value; marking tasks with a first tendency value greater than or equal to a first threshold as computational acceleration tasks; marking tasks with a first tendency value less than or equal to a second threshold as logical acceleration tasks; marking tasks with a first tendency value greater than the second threshold and less than the first threshold as tasks to be marked; extracting IoT metadata features of each task to be marked and calculating each metadata feature value of each task to be marked; calculating a second tendency value corresponding to each task to be marked based on a weighted method and each metadata feature value; marking tasks with a second tendency value greater than or equal to a third threshold as computational acceleration tasks; marking tasks with a second tendency value less than the third threshold as logical acceleration tasks; and assigning each task to the corresponding target acceleration engine for task processing according to the dependency relationship in the global task dependency graph and the task marking type.

[0079] Specifically, in the task labeling and allocation process, common features of each task are first extracted and corresponding feature values ​​are calculated. A weighted average is used to obtain a first tendency value, which is used to initially label the task type. Tasks with a first tendency value of 1 or higher are classified as computation acceleration tasks, those with a first tendency value of 1 or lower than the second threshold are classified as logic acceleration tasks, and those between the two thresholds are classified as tasks to be labeled. Next, IoT metadata features are extracted for tasks to be labeled and metadata feature values ​​are calculated. A weighted average is used to obtain a second tendency value, and tasks are further labeled as computation acceleration or logic acceleration tasks based on whether they reach the third threshold. Finally, by combining the dependency relationships in the global task dependency graph with the labeling type of each task, tasks are assigned to the corresponding target acceleration engines, achieving accurate task scheduling based on multi-feature hierarchical judgment and dependency collaboration. In this way, it can quickly complete the type labeling of most tasks by relying on general features, thereby improving processing efficiency. At the same time, it can achieve fine-grained differentiation for boundary-oriented tasks by using metadata features that are in line with IoT scenarios, avoiding allocation deviations caused by single feature judgments. Meanwhile, by combining the dependency relationships in the global task dependency graph for final allocation, it can ensure that task execution matches the dependency logic, effectively reduce scheduling conflicts between different types of tasks in the acceleration engine, give full play to the special performance advantages of the computing acceleration engine and the logic acceleration engine, and ultimately significantly improve the task processing efficiency and resource utilization accuracy in IoT high-concurrency and multi-type data scenarios.

[0080] For example, a first bias calculation formula is defined, using the weighted scoring formula: S = (W_d * N_d) + (W_p * N_p) + (W_m * N_m) + (W_t * N_t) to calculate the first bias value S, where N_* represents the normalized value of each feature, and its value range is mapped to [-1, +1], where +1 indicates a strong bias towards FPGA and -1 indicates a strong bias towards CPU, and W_* represents the weight of each feature. The sum of all weights is 1. Based on the first bias value S, the task type is determined. If S ≥ 0.4, it is marked as a computation acceleration task; if S ≤ -0.4, it is marked as a logic acceleration task; when the first bias value S is in the fuzzy range (-0.4 < S_general < 0.4), metadata-aware task classification is performed. Define a formula for calculating the second propensity score, using the weighted scoring formula: S_meta = (W_q*N_q) + (W_r * N_r) + (W_s * N_s) to calculate the second propensity score S_meta, where N_* represents the normalized value of each feature, with its range mapped to [-1, +1], where +1 indicates higher priority and computational intensity, and -1 indicates lower priority and computational intensity; W_* represents the weight of each feature. The sum of all weights is 1. Determine the task type based on the second propensity score S_meta: if S_meta ≥ 0, it is marked as a computationally accelerated task; if S_meta < 0, it is marked as a logically accelerated task.

[0081] Furthermore, the above-mentioned allocation of tasks to corresponding target acceleration engines for task processing based on the dependencies in the global task dependency graph and the task labeling type can specifically include: adding the task to the global ready queue when the pre-dependencies of the task are satisfied based on the dependency relationships; extracting tasks from the global ready queue, moving the task to the computation acceleration queue if the task is labeled as a computation acceleration task, and moving the task to the logic acceleration queue if the task is labeled as a logic acceleration task; monitoring the real-time load status of the computation acceleration engine and the logic acceleration engine; for the computation acceleration queue, extracting the first target task from the computation acceleration queue according to a first preset priority and allocating it to the computation acceleration engine with the lowest load; for the logic acceleration queue, extracting the second target task from the logic acceleration queue according to a second preset priority and allocating it to the logic acceleration engine with the lowest load; updating the status of the first target task / second target task to the completed status after execution on the corresponding computation acceleration engine / logic acceleration engine; triggering the pre-dependency check of subsequent dependent tasks and updating the global ready queue according to the check results.

[0082] Specifically, the global ready queue stores all tasks whose prerequisites have been satisfied, the computation acceleration queue stores all tasks whose prerequisites have been satisfied and marked as computation acceleration tasks, and the logical acceleration queue stores all tasks whose prerequisites have been satisfied and marked as logical acceleration tasks. The load status of the computation acceleration queue and the logical acceleration queue is continuously monitored. When an acceleration engine is idle, a task is selected from the global ready queue. According to scheduling rules, the task is assigned to an acceleration queue, as follows: if the task type matches the acceleration queue (e.g., the task type is a computation acceleration task and the idle queue is a computation acceleration queue), the task is immediately assigned to the computation acceleration queue; if the task type does not match the acceleration queue (e.g., the task type is a computation acceleration task and the idle queue is a logical acceleration queue), the task is not assigned temporarily, and the next candidate task is selected. In this way, the logical continuity of task execution can be ensured by relying on dependencies, avoiding execution chaos caused by unmet dependencies. Furthermore, by dividing queues by tag type and combining real-time load and preset priority allocation engines, the performance advantages of different acceleration engines can be fully adapted to achieve efficient resource utilization. At the same time, the dynamic update and cyclic triggering mechanism after task completion can quickly drive subsequent task scheduling, significantly improving the timeliness and overall efficiency of task processing in high-concurrency IoT scenarios.

[0083] Furthermore, the aforementioned pre-dependency check that triggers subsequent dependent tasks updates the global ready queue based on the check results. Specifically, this may include: updating the status of all subsequent tasks in their pre-dependencies for all subsequent tasks; checking whether all pre-dependencies of each subsequent task are in a completed state; and if so, adding the subsequent task to the global ready queue.

[0084] Specifically, for all subsequent tasks of a completed task, the global task dependency graph is updated. First, the status of the completed task in the prerequisite dependencies of each subsequent task is updated. Then, each subsequent task's prerequisite dependencies are checked to ensure they are all in a completed state. Only when all prerequisite dependencies of a subsequent task are completed is that subsequent task added to the global ready queue. This avoids misscheduling of tasks due to untimely or missed dependency status updates, and the strict criterion of all prerequisite dependencies being completed ensures that tasks entering the global ready queue are executable, reducing dependency conflicts during task execution at their source. Simultaneously, allowing only eligible tasks to enter the queue avoids queue redundancy, improving the efficiency of subsequent task allocation and scheduling, and providing a guarantee for the orderly and efficient processing of high concurrency and multiple tasks in IoT scenarios.

[0085] For example, the global task dependency graph is updated, removing the dependency counts of all successor tasks for this task. Any successor task whose dependency count drops to zero is immediately added to the global ready queue, thereby driving the scheduling loop to continue.

[0086] S103: After all tasks are completed, the processing results will be fed back to the IoT application.

[0087] Once all tasks corresponding to the computation request have been processed, the system integrates the processing results of all tasks, standardizes them according to a format recognizable by the IoT application, and finally feeds back the complete result set to the IoT application that initiated the request.

[0088] Furthermore, once all tasks are completed, the processing results are fed back to the IoT application. Specifically, this may include: obtaining the execution results of all tasks corresponding to the computing request; merging the execution results of each task based on the data relationships in the task dependencies; standardizing the format of the merged execution results and removing redundant data to generate a complete result set, and returning the complete result set to the IoT application.

[0089] Specifically, after all tasks corresponding to the computation request have been completed, the execution results of all tasks under the request are first summarized. Then, based on the data association logic inherent in the task dependency relationship, the scattered task results are integrated according to the association relationship. Subsequently, the merged results are subjected to format standardization processing (uniformly adapting to the application end's receiving format) and redundant data removal operations to form a complete and concise result set. Finally, the result set is returned to the IoT application end that initiated the request.

[0090] This ensures the logical coherence and data integrity of the results from each task, avoiding information gaps caused by fragmented results. The standardization of formats and the removal of redundant data allow IoT applications to directly parse and use the results without additional processing, reducing application adaptation costs, while also reducing the size of the result set and improving transmission efficiency. Overall, it provides IoT applications with complete, standardized, and efficient result feedback, effectively meeting the practicality and timeliness requirements of data processing loops in IoT scenarios.

[0091] The IoT data processing method provided in this invention involves acquiring a computing request initiated by an IoT application, splitting the computing request into multiple tasks, and parsing the dependencies between the tasks. The characteristics of each task are analyzed, and based on these characteristics and dependencies, each task is assigned to a target acceleration engine for processing. The target acceleration engine can be a computing acceleration engine or a logic acceleration engine. After all tasks are processed, the processing results are fed back to the IoT application. This method, by splitting the computing request into multiple tasks and parsing dependencies, enables refined management and collaborative processing of tasks, avoiding the inefficiency of overall request processing in traditional models. Assigning tasks to matching target acceleration engines (computing acceleration engines or logic acceleration engines) based on task characteristics allows for precise scheduling of dedicated engines handling dedicated tasks, reducing resource waste. Through a combination of task splitting, dependency collaboration, and precise allocation strategies, overall data processing efficiency can be improved, enhancing adaptability to high-concurrency, high-traffic IoT scenarios and maximizing overall system throughput and energy efficiency.

[0092] For a clearer understanding of this invention, please refer to the following details. Figure 2 and Figure 3 , Figure 2 This invention provides an architecture diagram of an IoT data processing acceleration system based on hardware and software integration, as an embodiment of the present invention. Figure 3 This is a flowchart illustrating an IoT data processing acceleration method provided in an embodiment of the present invention. Specifically, it may include:

[0093] The system comprises a control module, a dynamic scheduling engine, and an acceleration module. The control module, serving as the system's entry point, provides an API gateway, receiving application computation requests and connecting to the dynamic scheduling engine. The dynamic scheduling engine intelligently analyzes and decomposes tasks. Simultaneously, the control module is responsible for configuring, scheduling, and monitoring the system's hardware resources. The dynamic scheduling engine consists of three main modules: a dependency analyzer, a task classifier, and a scheduling decision-maker. The dependency analyzer decomposes requests into a series of tasks and resolves task dependencies. The task classifier analyzes task characteristics at runtime. The scheduling decision-maker allocates tasks to the most suitable acceleration processing unit (logic acceleration engine or computation acceleration engine) based on these characteristics, thereby maximizing the overall system throughput and energy efficiency. The acceleration module is divided into a logic acceleration engine and a computation acceleration engine. The logic acceleration engine runs on a general-purpose CPU, handling complex logic and branch-intensive tasks (such as protocol parsing and device scheduling). The computation acceleration engine runs on a heterogeneous FPGA computing card, specifically designed for handling tasks with high data parallelism, computational intensity, and latency sensitivity (such as video frame face detection and data filtering).

[0094] Specifically, the control module receives computing task requests from upper-layer applications through a preset API interface, such as computing requests for real-time analysis and early warning of security videos. The dynamic scheduling engine dynamically analyzes received computation requests, decomposing them into a series of tasks (video decoding (Job_A), face detection (Job_B), face alignment and feature extraction (Job_C), feature comparison and alarm decision (Job_D)) and their dependencies (directed edges), creating a global task dependency graph (Job_A --> (Job_B, Job_C) --> Job_D) using an adjacency list. The dynamic scheduling engine's task classifier performs general feature task classification on the decomposed tasks, extracting features such as computation density (N_d = 2 * (number of arithmetic and logical operation instructions / total number of instructions - 0.5)), parallelism factor (N_p = 2 * (number of iterations / parallelism - 0.5)), memory access pattern (N_m = 2 * (e^(-stride value / 64) - 0.5)), and data type flag (N_t = 1 - (2 * double-precision operands / total floating-point operands)). A first-preference calculation formula is defined, using a weighted scoring formula: S = The first bias value S is calculated using (W_d * N_d) + (W_p * N_p) + (W_m * N_m) + (W_t * N_t), where N_* represents the normalized value of each feature, mapped to [-1, +1], where +1 indicates a strong bias towards FPGA and -1 indicates a strong bias towards CPU. W_* represents the weight of each feature. The sum of all weights is 1. Based on the first bias value S, the task type is determined. If S ≥ 0.4, it is marked as a computation acceleration task; if S ≤ -0.4, it is marked as a logic acceleration task. When the first bias value S is in the fuzzy range (-0.4 < S_general < 0.4), metadata-aware task classification is performed. The metadata task classifier adds IoT metadata as a classification feature, extracting data source (N_s (preset value, range [-1, 1], the higher the value, the more likely it is to contain computationally intensive tasks (such as images, videos, etc.))) and data priority (N_q = 2 * ((QOS level + 1)). Features such as SUM (QOS level) - 0.5) and rule chain complexity (N_r = 2 * (min(number of operators / 10, 1.0) - 0.5)) are defined; the second tendency calculation formula is defined, and the second tendency value S_meta is calculated using the weighted scoring formula: S_meta = (W_q*N_q) + (W_r * N_r) + (W_s * N_s), where N_* represents the normalized value of each feature, and its value range is mapped to [-1, +1], where +1 indicates higher priority and computational intensity, and -1 indicates lower priority and computational intensity.W_* represents the weight of each feature. The sum of all weights is 1. The task type is determined based on the second tendency value S_meta. If S_meta ≥ 0, it is marked as a computational acceleration task; if S_meta < 0, it is marked as a logical acceleration task. Based on the first and second tendency calculation formulas, Job_A is marked as a logical acceleration task, Job_B as a computational acceleration task, Job_C as a computational acceleration task, and Job_D as a logical acceleration task. The task classifier of the dynamic scheduling engine submits the task to the scheduling decision-maker. Job_A has no prerequisite tasks, so the scheduling decision-maker of the dynamic scheduling engine stores Job_A in the global ready queue. The scheduling decision-maker continuously monitors the load status of the computational acceleration queue and the logical acceleration queue. When the acceleration engine is idle, the scheduling decision-maker selects task Job_A from the global ready queue. If Job_A is a logical acceleration task, the scheduling decision-maker of the dynamic scheduling engine stores Job_A in the logical acceleration queue. After task allocation, the dynamic scheduling engine returns the computational acceleration queue and the logical acceleration queue to the control module. The control module selects the task from the logical acceleration queue and assigns it to the task. The task is sent to the logic acceleration engine; after receiving the task, the acceleration module accelerates the task according to a preset method; after the task is completed, the acceleration module returns the task processing result to the control module; after receiving the task result, the control module synchronously sends a task completion signal to the dynamic scheduling engine; the dynamic scheduling engine updates the global task dependency graph, the dependency count of the successor tasks (Job_B, Job_C) of Job_A drops to zero, and the successor tasks (Job_B, Job_C) are immediately added to the global ready queue, thereby driving the scheduling loop to continue; after Job_A is processed, The scheduling decision-maker selects tasks Job_B and Job_C from the global ready queue. Job_B is a computation acceleration task, and the dynamic scheduling engine's scheduling decision-maker stores Job_B in the computation acceleration queue. Job_C is also a computation acceleration task; since Job_B is already stored in the computation acceleration queue, Job_C is not assigned yet. After task allocation, the dynamic scheduling engine returns the computation acceleration queue and the logical acceleration queue to the control module. The control module selects a task from the logical acceleration queue and sends it to the computation acceleration engine. Upon receiving the task, the acceleration module accelerates the task according to a preset method. After task processing is complete, the acceleration module returns the task processing result to the control module. Upon receiving the task result, the control module synchronously sends a task completion signal to the dynamic scheduling engine. (The text repeats itself here, so the translation reflects that.)After task processing is complete, the acceleration module returns the task processing result to the control module. Upon receiving the task result, the control module synchronously sends a task completion signal to the dynamic scheduling engine. The dynamic scheduling engine updates the global task dependency graph, reducing the dependency count of the successor task Job_D of (Job_B, Job_C) to zero, and immediately adding Job_D to the global ready queue. Job_D is a logical acceleration task, and the scheduling decision-maker of the dynamic scheduling engine stores Job_D in the logical acceleration queue. After task allocation is completed, the dynamic scheduling engine returns the computation acceleration queue and the logical acceleration queue to the control module. The control module selects a task from the logical acceleration queue and sends it to the logical acceleration engine. Upon receiving the task, the acceleration module accelerates the task according to a preset method. After task processing is complete, the acceleration module returns the task processing result to the control module. Upon receiving the task result, the control module synchronously sends a task completion signal to the dynamic scheduling engine. After all tasks are executed, the control module merges and organizes all task results to form a complete result set, which is then returned to the upper-layer application.

[0095] As can be seen, this invention can solve the technical problems of insufficient data processing performance, difficulty in developing hardware acceleration solutions, and poor flexibility in existing IoT technologies. It has the following beneficial effects:

[0096] (1) Significant performance improvement: Compared with the traditional pure software solution, the present invention can improve the query speed and data processing speed of IoT data by several times or even tens of times by offloading the computationally intensive tasks to the FPGA hardware, and significantly reduce the response latency.

[0097] (2) Excellent high-concurrency processing capability: Through hardware acceleration capability, the transaction processing volume (TPS) and query processing volume (QPS) per unit time are greatly improved, effectively solving the performance problem in high-concurrency scenarios.

[0098] (3) Excellent flexibility: The reconfigurable nature of FPGA enables this system to quickly adapt to new data processing algorithms and business logic through software-defined hardware, avoiding the rigidity defects of ASIC solutions.

[0099] The IoT data processing device provided in the embodiments of the present invention will be described below. The IoT data processing device described below and the IoT data processing method described above can be referred to each other.

[0100] Please refer to the details. Figure 4 , Figure 4 A schematic diagram of the structure of an Internet of Things (IoT) data processing device provided in an embodiment of the present invention may include:

[0101] The splitting and parsing module 100 is used to obtain the computing request initiated by the IoT application terminal, split the computing request into multiple tasks, and parse the dependency relationship between each task.

[0102] The analysis and allocation module 200 is used to analyze the characteristics of each task and allocate each task to a target acceleration engine for task processing based on the characteristics and the dependencies; the target acceleration engine is a computing acceleration engine or a logic acceleration engine.

[0103] The feedback module 300 is used to feed back the processing results to the IoT application terminal after all the tasks have been processed.

[0104] Based on the above embodiments, the splitting and parsing module 100 may include:

[0105] The splitting unit is used to obtain the computing request initiated by the IoT application terminal, split the computing request based on preset rules, and obtain multiple tasks.

[0106] The analysis unit is used to perform static and dynamic analysis on each of the tasks to obtain the explicit and implicit dependencies between the tasks, respectively.

[0107] The dependency graph construction unit is used to take each task as a graph node, take the explicit dependency relationship and the implicit dependency relationship as directed edges, and use the adjacency list method to construct a global task dependency graph that can reflect the dependency relationship between each task.

[0108] Based on the above embodiments, the analysis and allocation module 200 may include:

[0109] The feature extraction unit is used to extract general features and IoT metadata features for each of the tasks, and to determine the target acceleration engine for each task based on the general features and the IoT metadata features; the general features include at least computational density, parallelism factor, memory access form and data type flag; the IoT metadata features include at least data source, data priority and rule chain complexity.

[0110] Based on the above embodiments, the feature extraction unit may include:

[0111] A general feature extraction subunit is used to extract the general features of each of the tasks and calculate the general feature values ​​of each of the general features.

[0112] The first tendency value calculation subunit is used to calculate the first tendency value corresponding to each task based on the weighting method and each of the general feature values.

[0113] The first marking subunit is used to mark tasks whose first tendency value is greater than or equal to the first threshold as computation acceleration tasks;

[0114] The second marking subunit is used to mark tasks whose first tendency value is less than or equal to the second threshold as logical acceleration tasks;

[0115] The task to be labeled subunit is used to identify tasks whose first tendency value is greater than the second threshold and less than the first threshold as tasks to be labeled.

[0116] The cloud data extraction subunit is used to extract the IoT metadata features of each of the tasks to be labeled, and to calculate the metadata feature values ​​of each of the tasks to be labeled.

[0117] The second tendency value calculation subunit is used to calculate the second tendency value corresponding to each of the tasks to be labeled based on the weighting method and the metadata feature values.

[0118] The third marking subunit is used to mark tasks whose second tendency value is greater than or equal to the third threshold as computation acceleration tasks;

[0119] The fourth marking subunit is used to mark tasks whose second tendency value is less than the third threshold as logical acceleration tasks;

[0120] The allocation subunit is used to allocate each task to the corresponding target acceleration engine for task processing based on the dependency relationship in the global task dependency graph and the task's tag type.

[0121] Based on the above embodiments, the allocation subunit may include:

[0122] The ready queue processing subunit is used to add the task to the global ready queue when the prerequisite dependencies of the task are satisfied based on the dependency relationship.

[0123] The task allocation subunit is used to extract the task from the global ready queue. If the task is marked as a computation acceleration task, the task is moved into the computation acceleration queue. If the task is marked as a logic acceleration task, the task is moved into the logic acceleration queue.

[0124] The load status monitoring subunit is used to monitor the real-time load status of the computing acceleration engine and the logic acceleration engine.

[0125] The first allocation subunit is used to extract a first target task from the computing acceleration queue according to a first preset priority and allocate it to the computing acceleration engine with the lowest load.

[0126] The second allocation subunit is used to extract the second target task from the logical acceleration queue according to the second preset priority and allocate it to the logical acceleration engine with the lowest load.

[0127] The first state update subunit is used to update the state of the first target task / second target task to the completed state after the first target task / second target task has been executed on the corresponding computing acceleration engine / logic acceleration engine;

[0128] The check result update subunit is used to trigger subsequent pre-dependency checks that depend on the task, and to update the global ready queue based on the check result.

[0129] Based on the above embodiments, the check result update subunit may include:

[0130] The second state update subunit is used to update the state of the successor task in the preceding dependencies for all successor tasks of the task.

[0131] The status check subunit is used to check whether all the prerequisites of each of the subsequent tasks are in a completed state.

[0132] The ready queue update sub-unit is used to add the subsequent task to the global ready queue if the condition is met.

[0133] Based on the above embodiments, the feedback module 300 may include:

[0134] An execution result acquisition unit is used to acquire the execution results of all tasks corresponding to the computation request;

[0135] The execution result merging unit is used to merge the execution results of each task according to the data association relationship in the dependency relationship of the task;

[0136] The execution result return unit is used to standardize the format of the merged execution results and remove redundant data to generate a complete result set, and return the complete result set to the IoT application terminal.

[0137] It should be noted that the order of the modules and units in the above-mentioned IoT data processing device can be changed without affecting the logic.

[0138] The IoT data processing device provided in this embodiment of the invention uses a splitting and parsing module 100 to obtain computing requests initiated by an IoT application, split the computing requests into multiple tasks, and parse the dependencies between the tasks. An analysis and allocation module 200 analyzes the characteristics of each task and allocates each task to a target acceleration engine for processing based on the characteristics and dependencies. The target acceleration engine is either a computing acceleration engine or a logic acceleration engine. A feedback module 300 feeds back the processing results to the IoT application after all tasks have been processed. This device, by splitting computing requests into multiple tasks and parsing dependencies, enables refined management and collaborative processing of tasks, avoiding the inefficiency of overall request processing in traditional models. Allocating tasks to matching target acceleration engines (computing acceleration engines or logic acceleration engines) based on task characteristics allows for precise scheduling of dedicated engines for dedicated tasks, reducing resource waste. Through a combination of task splitting, dependency collaboration, and precise allocation strategies, overall data processing efficiency can be improved, enhancing adaptability to high-concurrency, high-traffic IoT scenarios.

[0139] The following describes the IoT data processing device provided in the embodiments of the present invention. The IoT data processing device described below and the IoT data processing method described above can be referred to each other.

[0140] Please refer to Figure 5 , Figure 5 A schematic diagram of the structure of an Internet of Things (IoT) data processing device provided in an embodiment of the present invention may include:

[0141] Memory 10 is used to store computer programs;

[0142] The processor 20 is used to execute computer programs to implement the above-described Internet of Things (IoT) data processing method.

[0143] The memory 10, processor 20, and communication interface 31 all communicate with each other through the communication bus 32.

[0144] In this embodiment of the invention, the memory 10 is used to store one or more programs. The programs may include program code, which includes computer operation instructions. In this embodiment of the invention, the memory 10 may store programs for implementing the following functions:

[0145] Obtain computing requests initiated by IoT applications, break down the computing requests into multiple tasks, and resolve the dependencies between the tasks;

[0146] Analyze the characteristics of each task, and assign each task to the target acceleration engine for task processing based on the characteristics and dependencies; the target acceleration engine is either a computational acceleration engine or a logic acceleration engine.

[0147] Once all tasks are completed, the results will be fed back to the IoT application.

[0148] In one possible implementation, the memory 10 may include a program storage area and a data storage area, wherein the program storage area may store the operating system and applications required for at least one function; and the data storage area may store data created during use.

[0149] Furthermore, memory 10 may include read-only memory and random access memory, providing instructions and data to the processor. A portion of the memory may also include NVRAM. The memory stores operating systems and operating instructions, executable modules, or data structures, or subsets thereof, or extended sets thereof, wherein the operating instructions may include various operating instructions for implementing various operations. The operating system may include various system programs for implementing various basic tasks and handling hardware-based tasks.

[0150] Processor 20 can be a central processing unit (CPU), an application-specific integrated circuit, a digital signal processor, a field-programmable gate array, or other programmable logic device. Processor 20 can be a microprocessor or any conventional processor. Processor 20 can call programs stored in memory 10.

[0151] The communication interface 31 can be the interface of the communication module, used to connect with other devices or systems.

[0152] Of course, it should be noted that, Figure 5 The structure shown does not constitute a limitation on the IoT data processing device in the embodiments of the present invention. In practical applications, the IoT data processing device may include more than Figure 5 More or fewer components as shown, or combinations of certain components.

[0153] The following describes the computer-readable storage medium provided in the embodiments of the present invention. The computer-readable storage medium described below can be referred to in correspondence with the Internet of Things data processing method described above.

[0154] The present invention also provides a computer-readable storage medium storing a computer program, which, when executed by a processor, implements the steps of the above-described Internet of Things data processing method.

[0155] The computer-readable storage medium may include various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0156] The various embodiments in this specification are described in a progressive manner, with each embodiment focusing on its differences from other embodiments. Similar or identical parts between embodiments can be referred to interchangeably. For the apparatus disclosed in the embodiments, since it corresponds to the method disclosed in the embodiments, the description is relatively simple; relevant parts can be referred to the method section.

[0157] Those skilled in the art will further recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, computer software, or a combination of both. To clearly illustrate the interchangeability of hardware and software, the components and steps of the various examples have been generally described in terms of functionality in the foregoing description. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementations should not be considered beyond the scope of this invention.

[0158] Finally, it should be noted that in this document, relationships such as "first" and "second" are used merely to distinguish one entity or operation from another, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Furthermore, the terms "comprising," "including," or any other variations are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such process, method, article, or apparatus.

[0159] The present invention provides a detailed description of an Internet of Things (IoT) data processing method, apparatus, device, and computer-readable storage medium. Specific examples have been used to illustrate the principles and implementation methods of the present invention. The descriptions of the above embodiments are only for the purpose of helping to understand the method and core ideas of the present invention. At the same time, those skilled in the art will recognize that, based on the ideas of the present invention, there will be changes in the specific implementation methods and application scope. Therefore, the content of this specification should not be construed as a limitation of the present invention.

Claims

1. An Internet of Things (IoT) data processing method, characterized in that, include: Obtain computing requests initiated by IoT application terminals, break down the computing requests into multiple tasks, and parse the dependencies between the tasks; Analyze the characteristics of each task, and assign each task to a target acceleration engine for task processing based on the characteristics and dependencies; The target acceleration engine is a computational acceleration engine or a logic acceleration engine; Once all the tasks have been completed, the processing results will be fed back to the IoT application.

2. The IoT data processing method according to claim 1, characterized in that, Obtain computing requests initiated by IoT application terminals, break down the computing requests into multiple tasks, and parse the dependencies between the tasks, including: The computing request initiated by the IoT application is obtained, and the computing request is split according to a preset rule to obtain multiple tasks; Static and dynamic analyses are performed on each task to obtain the explicit and implicit dependencies between them. Each task is treated as a graph node, and the explicit and implicit dependencies are treated as directed edges. An adjacency list is used to construct a global task dependency graph that reflects the dependencies between the tasks.

3. The IoT data processing method according to claim 1, characterized in that, Analyze the characteristics of each task, and assign each task to a target acceleration engine for task processing based on the characteristics and dependencies, including: Extract the general features and IoT metadata features of each task, and determine the target acceleration engine for each task based on the general features and IoT metadata features; the general features include at least computational density, parallelism factor, memory access form and data type flag; the IoT metadata features include at least data source, data priority and rule chain complexity.

4. The IoT data processing method according to claim 3, characterized in that, Extracting common features and IoT metadata features for each task, and determining the target acceleration engine for each task based on the common features and IoT metadata features, including: Extract the common features of each task and calculate the common feature values ​​of each common feature; Based on the weighted method and each of the general feature values, the first tendency value corresponding to each of the tasks is calculated. Tasks with a first tendency value greater than or equal to a first threshold are marked as computation acceleration tasks; Tasks whose first tendency value is less than or equal to the second threshold are marked as logic acceleration tasks; Tasks whose first tendency value is greater than the second threshold and less than the first threshold are designated as tasks to be labeled. Extract the IoT metadata features of each of the tasks to be labeled, and calculate the metadata feature values ​​of each of the tasks to be labeled. Based on the weighted method and the metadata feature values, the second tendency value corresponding to each of the tasks to be labeled is calculated; Tasks with a second tendency value greater than or equal to the third threshold are marked as computation acceleration tasks; Tasks whose second tendency value is less than the third threshold are marked as logic acceleration tasks; Based on the dependencies in the global task dependency graph and the task's tag type, each task is assigned to the corresponding target acceleration engine for task processing.

5. The Internet of Things data processing method according to claim 4, characterized in that, Based on the dependencies in the global task dependency graph and the task's tag type, each task is assigned to a corresponding target acceleration engine for processing, including: When it is determined that the prerequisites of the task are satisfied based on the aforementioned dependency relationship, the task is added to the global ready queue. The task is extracted from the global ready queue. If the task is marked as a computation acceleration task, the task is moved into the computation acceleration queue. If the task is marked as a logic acceleration task, the task is moved into the logic acceleration queue. Monitor the real-time load status of the computing acceleration engine and the logic acceleration engine; For the computing acceleration queue, a first target task is extracted from the computing acceleration queue according to a first preset priority and assigned to the computing acceleration engine with the lowest load; For the logical acceleration queue, the second target task is extracted from the logical acceleration queue according to the second preset priority and assigned to the logical acceleration engine with the lowest load; Once the first target task / second target task has been completed on the corresponding computing acceleration engine / logic acceleration engine, the status of the first target task / second target task will be updated to the completed status. Trigger a pre-dependency check for subsequent tasks that depend on the task, and update the global ready queue based on the check results.

6. The Internet of Things data processing method according to claim 5, characterized in that, Trigger a pre-dependency check for subsequent tasks that depend on the task, and update the global ready queue based on the check results, including: For all successor tasks of the task, update the state of the successor task in its predecessor dependencies; Check whether all the prerequisites of each of the subsequent tasks are in a completed state; If so, the subsequent task is added to the global ready queue.

7. The Internet of Things data processing method according to claim 1, characterized in that, Once all the tasks have been completed, the processing results will be fed back to the IoT application, including: Obtain the execution results of all tasks corresponding to the computation request; Based on the data relationships in the dependencies of the tasks, the execution results of each task are merged; The merged execution results are formatted and redundant data is removed to generate a complete result set, which is then returned to the IoT application.

8. An Internet of Things (IoT) data processing device, characterized in that, include: The splitting and parsing module is used to obtain the computing request initiated by the IoT application, split the computing request into multiple tasks, and parse the dependency relationship between each task. An analysis and allocation module is used to analyze the characteristics of each task and allocate each task to a target acceleration engine for task processing based on the characteristics and the dependencies. The target acceleration engine is a computational acceleration engine or a logic acceleration engine; The feedback module is used to send the processing results back to the IoT application terminal after all the tasks have been processed.

9. An Internet of Things (IoT) data processing device, characterized in that, include: Memory, used to store computer programs; A processor for executing the computer program to implement the Internet of Things data processing method as described in any one of claims 1 to 7.

10. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores computer-executable instructions, which, when loaded and executed by a processor, implement the Internet of Things data processing method as described in any one of claims 1 to 7.

Images