Internet of Things gateway design method and system based on parallel computing
By dividing the tasks of the IoT gateway into CPU and GPU tasks, and adopting heterogeneous computing and multi-threading design, the performance bottleneck problem of IoT gateways when processing large amounts of data and multi-tasks is solved, and the processing efficiency and throughput are significantly improved. .
Patent Information
- Application Number
- CN202410978353.2
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2024-07-22
- Publication Date
- 2024-11-15
AI Technical Summary
When existing IoT gateway designs process large amounts of data and multitasking, the CPU's processing speed becomes a bottleneck, making it difficult to meet the growing data processing needs.
Using a design method based on parallel computing, software tasks are divided into CPU tasks and GPU tasks. The CPU is responsible for logical control and data acquisition, while the GPU is responsible for computing-intensive tasks, such as encryption and decryption and data filtering, through heterogeneous computing frameworks such as OpenCL, CUDA issues kernel functions to GPU processing unit and adopts multi-threaded design and efficient memory database storage structure.
It significantly improves the task throughput and overall processing efficiency of the Internet of Things gateway, fully utilizes the performance characteristics of the CPU and GPU, avoids the CPU to perform heavy computing tasks, and realizes efficient data processing and resource utilization.
Smart Images

Figure CN118964008A_ABST
Abstract
Description
Technical Field
[0001] The present invention relates to the technical field of Internet of Things gateway design, and in particular to an Internet of Things gateway design method and system based on parallel computing. Background Art
[0002] The IoT gateway is a key component in the IoT architecture. It is usually located at the network layer and acts as a bridge between the sensor layer and the application layer. It is responsible for collecting raw data from the sensor layer devices, converting it into a format suitable for transmission in the network, and performing preliminary data processing and aggregation. The IoT gateway also undertakes tasks such as security, protocol conversion, data filtering, and edge computing to ensure that data can be effectively transmitted from terminal devices to the cloud or enterprise-level applications.
[0003] With the rapid development of IoT technology and the popularization of its applications, the number of nodes in the perception layer is increasing, and the access requirements of the application layer are also increasing sharply. Therefore, the number of tasks that IoT gateways need to process is also increasing sharply. However, most of the existing gateway design solutions use the CPU as the processing core. When the number of tasks that need to be processed per unit time reaches a certain number, the CPU processing speed becomes a bottleneck, making it difficult to meet the growing data processing needs.
[0004] With the continuous maturity of various hardware acceleration technologies represented by GPU, heterogeneous computing mode has become one of the important means to solve large-scale computing problems. Heterogeneous computing requires the coordination of various computing devices including CPU (such as GPU, FPGA, DSP, etc.), assigning computing tasks to different computing devices according to their characteristics, giving full play to the different characteristics of various computing devices, and collaboratively solving problems. This computing mode can not only significantly improve processing speed, but also optimize energy consumption ratio and achieve more efficient resource utilization.
[0005] Therefore, how to utilize the parallel computing capabilities of modern computing hardware to improve the task processing efficiency of IoT gateways has become an issue worthy of study. Summary of the invention
[0006] The technical task of the present invention is to address the above shortcomings and provide an Internet of Things gateway design method and system based on parallel computing, which can solve the problems of high data traffic, multi-task processing and increasing real-time requirements faced by the existing technology, and improve the overall task processing efficiency of the Internet of Things gateway.
[0007] The technical solution adopted by the present invention to solve its technical problem is:
[0008] A design method for an IoT gateway based on parallel computing divides software tasks into CPU tasks and GPU tasks based on preset division rules according to the functions that the gateway needs to implement;
[0009] CPU tasks include the collection of sensor layer data and the issuance of control commands, the uploading and receiving of network layer data, as well as key functions such as overall task scheduling and logic control;
[0010] GPU tasks are computationally intensive, including encryption and decryption, data filtering, data preprocessing, and edge computing;
[0011] For the GPU tasks, a task subdivision strategy is further adopted to decompose complex tasks into finer-grained computing subtasks, and write dedicated kernel functions for each subtask; these kernel functions are optimized and compiled and converted into GPU executable binary files. During the initialization of the gateway program, the kernel functions are sent to the processing units in the GPU through general heterogeneous computing frameworks such as OpenCL, CUDA, etc., for CPU scheduling and execution.
[0012] Through this heterogeneous design, the CPU focuses on tasks such as logic control, task scheduling, data acquisition, command reception and transmission, while the GPU takes on the processing of computationally intensive tasks. This division of labor design fully utilizes the performance characteristics of each processor, effectively avoids the CPU from performing heavy computing tasks, significantly improves the task throughput of the gateway, and improves the overall task processing efficiency of the IoT gateway.
[0013] Furthermore, the storage structure uses an efficient in-memory database storage method to ensure fast access to data:
[0014] In the database, for each type of data that needs to be processed, a corresponding data table and a data table for storing processed data are created. For example, each sensor device corresponds to a data table to achieve orderly management and rapid retrieval of data.
[0015] For different processing units in the GPU and their corresponding kernel functions, a kernel function resource table is established to store and maintain the processing unit status in the GPU in real time.
[0016] Furthermore, the overall task scheduling of the gateway adopts a multi-threaded design method:
[0017] When the CPU is executing a task,
[0018] The data collection thread writes the collected sensor layer data into the corresponding local database table in the gateway;
[0019] The resource maintenance thread monitors the computing resource status of the GPU processor in real time and maintains the kernel function resource table;
[0020] The task scheduling thread uses pattern matching algorithms and metadata analysis to monitor the matching between the kernel function resource table and the data table in real time. Once a match is found, the task execution thread is notified through the semaphore mechanism to execute the task processing flow.
[0021] The task execution thread passes the data in the data table to the corresponding calculation kernel function for processing. After the data processing is completed, the GPU notifies the data reading thread through the interrupt mechanism to read back the processing result data and write it into the corresponding processed data table;
[0022] The task response thread is responsible for reading the corresponding processed data table and forwarding the processed data to the corresponding communication interface, thus realizing a closed loop of data processing.
[0023] Furthermore, the hardware components include:
[0024] The top layer is the network access layer, which is oriented to cloud servers or enterprise applications and integrates multiple communication interfaces, including fiber optic interface units, RJ45 interface units, WIFI interface units, 4G / 5G interface units, and NBIOT interface units. This layer is flexibly designed and can dynamically add or delete interface units in the gateway according to actual network access needs, thereby achieving highly customized network access solutions.
[0025] The middle layer is the task processing layer, which adopts a heterogeneous design mode combining CPU and GPU, making full use of their respective performance advantages to collaboratively complete key tasks such as data processing, task scheduling and storage management;
[0026] The bottom layer is the data acquisition and interactive control layer, which faces the sensor layer and is responsible for data acquisition and the issuance of control commands. This layer integrates a variety of communication interfaces, including Bluetooth, Zigbee, LoRa, RS485, RS232 and other data interface units. It also supports flexible addition and deletion of interface unit designs in the gateway according to the data access requirements of the sensor layer to meet the data acquisition and interactive control requirements in different scenarios.
[0027] Furthermore, in the task processing layer, the CPU processor and the GPU processor are connected through a PCIE high-speed bus, ensuring high bandwidth and low latency in communication, and providing a solid hardware foundation for efficient data processing.
[0028] Furthermore, the software task is divided into CPU tasks and GPU tasks based on a preset division rule, and the preset division rule is used to determine whether the software task is a computationally intensive task or a logic analysis or control task.
[0029] Furthermore, the implementation process of this method is as follows:
[0030] S1. List all the functional tasks that the software needs to implement according to the functions that the gateway needs to implement;
[0031] S2. Divide the tasks into CPU tasks and GPU tasks according to preset rules;
[0032] S3, design the corresponding CPU task processing program;
[0033] S4. For GPU tasks, we further adopt a subdivision strategy to decompose complex computing tasks into computing subtasks with finer granularity.
[0034] S5. Design the corresponding computing kernel function for GPU subtasks;
[0035] S6, the kernel function is optimized and compiled and converted into a binary file executable by the GPU;
[0036] S7. During the CPU program execution, the kernel function is sent to the processing unit in the GPU through the heterogeneous computing framework for CPU scheduling.
[0037] The present invention also claims to protect an Internet of Things gateway system based on parallel computing, including a CPU task module and a GPU task module; the CPU tasks and the GPU tasks are divided according to the functions that the gateway needs to implement based on preset division rules.
[0038] The CPU tasks include the collection of sensor layer data and the issuance of control commands, the uploading and receiving of network layer data, as well as key functions such as overall task scheduling and logic control;
[0039] The GPU tasks are computationally intensive tasks, including encryption and decryption, data filtering, data preprocessing, and edge computing;
[0040] The GPU task module adopts a task subdivision strategy to further decompose complex GPU tasks into finer-grained computing subtasks, and writes dedicated kernel functions for each subtask; these kernel functions are optimized and compiled and converted into GPU executable binary files. During the initialization of the gateway program, the kernel functions are sent to the processing units in the GPU through common heterogeneous computing frameworks such as OpenCL and CUDA, so as to be scheduled and executed by the CPU;
[0041] The system specifically implements parallel computing of the Internet of Things gateway through the above-mentioned Internet of Things gateway design method based on parallel computing.
[0042] The present invention also claims protection for an IoT gateway implementation device based on parallel computing, comprising: at least one memory and at least one processor;
[0043] The at least one memory is used to store a machine-readable program;
[0044] The at least one processor is used to call the machine-readable program to implement the above method.
[0045] The present invention also claims protection for a computer-readable medium having computer instructions stored thereon, which implement the above method when executed by a processor.
[0046] Compared with the prior art, the IoT gateway design method and system based on parallel computing of the present invention have the following beneficial effects:
[0047] This method divides software tasks into CPU tasks and GPU tasks according to the functions that the gateway needs to implement; the CPU is focused on tasks such as logic control, task scheduling, data acquisition, command reception and transmission, while the GPU is responsible for processing computationally intensive tasks. This division of labor design fully utilizes the performance characteristics of each processor, effectively avoids the CPU from performing heavy computing tasks, significantly improves the task throughput of the gateway, and improves the overall task processing efficiency of the IoT gateway. BRIEF DESCRIPTION OF THE DRAWINGS
[0048] Figure 1 This is a diagram of an Internet of Things gateway architecture based on parallel computing provided by an embodiment of the present invention;
[0049] Figure 2 It is a flowchart of an Internet of Things gateway method based on parallel computing provided by an embodiment of the present invention;
[0050] Figure 3 It is a diagram showing overall task scheduling of a gateway provided by an embodiment of the present invention. DETAILED DESCRIPTION
[0051] The present invention will be further described below in conjunction with specific embodiments.
[0052] The embodiment of the present invention provides an Internet of Things gateway design method based on parallel computing. In terms of software design, according to the functions that the gateway needs to implement, based on preset division rules, the software tasks are divided into CPU tasks and GPU tasks; the preset division rules mainly determine whether the software task is a computationally intensive task or a logic analysis and control task.
[0053] CPU tasks cover key functions such as the collection of sensor layer data and the issuance of control commands, the uploading and receiving of network layer data, as well as overall task scheduling, logical control, etc.
[0054] GPU tasks are mainly computationally intensive tasks such as encryption and decryption, data filtering, data preprocessing, and edge computing.
[0055] For the GPU tasks, a task subdivision strategy is further adopted to decompose complex tasks into finer-grained computing subtasks, and write dedicated kernel functions for each subtask; these kernel functions are optimized and compiled and converted into GPU executable binary files. During the initialization of the gateway program, the kernel functions are sent to the processing units in the GPU through general heterogeneous computing frameworks such as OpenCL, CUDA, etc., for CPU scheduling and execution.
[0056] The specific task design process is as follows Figure 2 As shown:
[0057] S1. List all the functional tasks that the software needs to implement according to the functions that the gateway needs to implement;
[0058] S2. Divide the tasks into CPU tasks and GPU tasks according to preset rules;
[0059] S3, design the corresponding CPU task processing program;
[0060] S4. For GPU tasks, we further adopt a subdivision strategy to decompose complex computing tasks into computing subtasks with finer granularity.
[0061] S5. Design the corresponding computing kernel function for GPU subtasks;
[0062] S6, the kernel function is optimized and compiled and converted into a binary file executable by the GPU;
[0063] S7. During the CPU program execution, the kernel function is sent to the processing unit in the GPU through the heterogeneous computing framework for CPU scheduling.
[0064] In terms of storage structure design, an efficient memory database storage method is adopted to ensure fast data access:
[0065] In the database, for each type of data that needs to be processed, a corresponding data table and a data table for storing processed data are created. For example, each sensor device corresponds to a data table, which realizes orderly management and rapid retrieval of data.
[0066] For different processing units in the GPU and their corresponding kernel functions, a kernel function resource table is established to store and maintain the processing unit status in the GPU in real time.
[0067] Table 1 - Data sheet
[0068] Sensor Data Type Kernel function types Has it been processed? Processing Priority
[0069] Table 2 - Resource Table
[0070] Processing unit ID Kernel function types Input parameter storage area Processing unit status .
[0071] In terms of the overall task scheduling of the gateway, a multi-threaded design method is adopted. Figure 3 As shown in the figure, when the CPU is executing task processing, the data acquisition thread writes the collected sensor layer data into the corresponding local database table in the gateway; the resource maintenance thread monitors the computing resource status of the GPU processor in real time and maintains the kernel function resource table; the task scheduling thread monitors the matching between the kernel function resource table and the data table in real time through pattern matching algorithm and metadata analysis. Once a match is found, the task execution thread is notified through the semaphore mechanism to execute the task processing flow; the task execution thread passes the data in the data table to the corresponding computing kernel function for processing. After the data processing is completed, the GPU notifies the data reading back thread through the interrupt mechanism, reads back the processing result data, and writes it into the corresponding processed data table; the task response thread is responsible for reading the corresponding processed data table and forwarding the processed data to the corresponding communication interface, realizing a closed loop of data processing.
[0072] This method can be applied to heterogeneous computing, data processing and IoT gateway design. Through this heterogeneous design, the CPU focuses on tasks such as logic control, task scheduling, data acquisition, command reception and transmission, while the GPU takes on the processing of computationally intensive tasks. This division of labor design fully utilizes the performance characteristics of each processor, effectively avoids the CPU from performing heavy computing tasks, significantly improves the task throughput of the gateway, and improves the overall task processing efficiency of the IoT gateway.
[0073] like Figure 1 As shown, the IoT gateway designed by this method adopts an innovative three-layer architecture design in hardware composition to adapt to diverse network environments and application requirements.
[0074] The top layer is the network access layer, which is oriented to cloud servers or enterprise applications and integrates multiple communication interfaces, including fiber interface units, RJ45 interface units, WIFI interface units, 4G / 5G interface units, and NBIOT interface units. This layer is designed flexibly and can dynamically add or delete interface units in the gateway according to actual network access needs, thus realizing highly customized network access solutions.
[0075] The middle layer is the task processing layer, which adopts a heterogeneous design mode combining CPU and GPU, making full use of their respective performance advantages to collaboratively complete key tasks such as data processing, task scheduling and storage management. The CPU processor and GPU processor are connected through the PCIE high-speed bus, ensuring high bandwidth and low latency of communication, providing a solid hardware foundation for efficient data processing.
[0076] The bottom layer is the data acquisition and interactive control layer, which faces the sensor layer and is responsible for data acquisition and the issuance of control commands. This layer integrates a variety of communication interfaces, including Bluetooth, Zigbee, LoRa, RS485, RS232 and other data interface units. It also supports flexible addition and deletion of interface unit designs in the gateway according to the data access requirements of the sensor layer to meet the data acquisition and interactive control requirements in different scenarios.
[0077] The embodiment of the present invention also provides an Internet of Things gateway system based on parallel computing, including a CPU task module and a GPU task module; the CPU task and the GPU task are divided according to the functions that the gateway needs to realize based on preset division rules.
[0078] The CPU tasks include the collection of sensor layer data and the issuance of control commands, the uploading and receiving of network layer data, as well as key functions such as overall task scheduling and logic control;
[0079] The GPU tasks are computationally intensive tasks, including encryption and decryption, data filtering, data preprocessing, and edge computing;
[0080] The GPU task module adopts a task subdivision strategy to further decompose complex GPU tasks into finer-grained computing subtasks, and writes dedicated kernel functions for each subtask; these kernel functions are optimized and compiled and converted into GPU executable binary files. During the initialization of the gateway program, the kernel functions are sent to the processing units in the GPU through common heterogeneous computing frameworks such as OpenCL and CUDA, so as to be scheduled and executed by the CPU;
[0081] The system specifically implements IoT gateway parallel computing through the above-mentioned IoT gateway design method based on parallel computing. The specific process is as follows:
[0082] S1. List all the functional tasks that the software needs to implement according to the functions that the gateway needs to implement;
[0083] S2. Divide the tasks into CPU tasks and GPU tasks according to preset rules;
[0084] S3, design the corresponding CPU task processing program;
[0085] S4. For GPU tasks, we further adopt a subdivision strategy to decompose complex computing tasks into computing subtasks with finer granularity.
[0086] S5. Design the corresponding computing kernel function for GPU subtasks;
[0087] S6, the kernel function is optimized and compiled and converted into a binary file executable by the GPU;
[0088] S7. During the CPU program execution, the kernel function is sent to the processing unit in the GPU through the heterogeneous computing framework for CPU scheduling.
[0089] In terms of storage structure design, the system adopts an efficient memory database storage method to ensure fast data access. In the database, for each type of data that needs to be processed, a corresponding data table and a data table for storing processed data are created, such as a data table corresponding to each sensor device, which realizes orderly management and fast retrieval of data; for different processing units in the GPU and the corresponding kernel functions, a kernel function resource table is established to store and maintain the processing unit status in the GPU in real time.
[0090] The system adopts a multi-threaded design method in terms of overall task scheduling of the gateway. When the CPU is executing task processing, the data acquisition thread writes the collected sensor layer data into the corresponding local database table in the gateway; the resource maintenance thread monitors the computing resource status of the GPU processor in real time and maintains the kernel resource table; the task scheduling thread monitors the matching between the kernel resource table and the data table in real time through pattern matching algorithm and metadata analysis. Once a match is found, the task execution thread is notified through the semaphore mechanism to execute the task processing flow; the task execution thread transfers the data in the data table to the corresponding computing kernel function for processing. After the data processing is completed, the GPU notifies the data reading thread through the interrupt mechanism, reads back the processing result data, and writes it into the corresponding processed data table; the task response thread is responsible for reading the corresponding processed data table and forwarding the processed data to the corresponding communication interface, realizing a closed loop of data processing.
[0091] The system hardware adopts an innovative three-layer architecture design to adapt to diverse network environments and application requirements:
[0092] The top layer is the network access layer, which is oriented to cloud servers or enterprise applications and integrates multiple communication interfaces, including fiber interface units, RJ45 interface units, WIFI interface units, 4G / 5G interface units, and NBIOT interface units. This layer is designed flexibly and can dynamically add or delete interface units in the gateway according to actual network access needs, thus realizing highly customized network access solutions.
[0093] The middle layer is the task processing layer, which adopts a heterogeneous design mode combining CPU and GPU, making full use of their respective performance advantages to collaboratively complete key tasks such as data processing, task scheduling and storage management. The CPU processor and GPU processor are connected through the PCIE high-speed bus, ensuring high bandwidth and low latency of communication, providing a solid hardware foundation for efficient data processing.
[0094] The bottom layer is the data acquisition and interactive control layer, which faces the sensor layer and is responsible for data acquisition and the issuance of control commands. This layer integrates a variety of communication interfaces, including Bluetooth, Zigbee, LoRa, RS485, RS232 and other data interface units. It also supports flexible addition and deletion of interface unit designs in the gateway according to the data access requirements of the sensor layer to meet the data acquisition and interactive control requirements in different scenarios.
[0095] The embodiment of the present invention also provides an IoT gateway implementation device based on parallel computing, comprising: at least one memory and at least one processor;
[0096] The at least one memory is used to store a machine-readable program;
[0097] The at least one processor is used to call the machine-readable program to implement the Internet of Things gateway design method based on parallel computing described in the above embodiment.
[0098] The embodiment of the present invention also provides a computer-readable medium, on which computer instructions are stored, and when the computer instructions are executed by the processor, the method for designing an Internet of Things gateway based on parallel computing described in the above embodiment is implemented. Specifically, a system or device equipped with a storage medium can be provided, on which a software program code for implementing the functions of any of the above embodiments is stored, and a computer (or CPU or MPU) of the system or device is enabled to read and execute the program code stored in the storage medium.
[0099] In this case, the program code itself read from the storage medium can realize the function of any one of the above-mentioned embodiments, and thus the program code and the storage medium storing the program code constitute a part of the present invention.
[0100] The storage medium embodiments for providing the program code include a floppy disk, a hard disk, a magneto-optical disk, an optical disk (such as CD-ROM, CD-R, CD-RW, DVD-ROM, DVD-RAM, DVD-RW, DVD+RW), a magnetic tape, a non-volatile memory card, and a ROM. Alternatively, the program code can be downloaded from a server computer by a communication network.
[0101] In addition, it should be clear that the functions of any of the above embodiments can be implemented not only by executing the program code read by the computer, but also by enabling an operating system operating on the computer to complete part or all of the actual operations based on instructions from the program code.
[0102] In addition, it can be understood that the program code read from the storage medium is written to a memory provided in an expansion board inserted into the computer or written to a memory provided in an expansion unit connected to the computer, and then based on the instructions of the program code, a CPU installed on the expansion board or the expansion unit is enabled to perform part or all of the actual operations, thereby realizing the functions of any of the above-mentioned embodiments.
[0103] The present invention has been shown and described in detail above through the accompanying drawings and preferred embodiments. However, the present invention is not limited to these disclosed embodiments. Based on the above multiple embodiments, those skilled in the art can know that the code review methods in the above different embodiments can be combined to obtain more embodiments of the present invention, and these embodiments are also within the protection scope of the present invention.
Claims
1. A method for designing an Internet of Things gateway based on parallel computing, characterized in that: According to the functions that the gateway needs to achieve, the software tasks are divided into CPU tasks and GPU tasks based on the preset division rules; CPU tasks include the collection of sensor layer data and the issuance of control commands, the uploading and receiving of network layer data, as well as overall task scheduling and logic control functions; GPU tasks are computationally intensive, including encryption and decryption, data filtering, data preprocessing, and edge computing; For the GPU task, a task subdivision strategy is further adopted to decompose the task into computing subtasks, and a dedicated kernel function is written for each subtask; these kernel functions are optimized and compiled and converted into GPU executable binary files. During the initialization of the gateway program, the kernel functions are sent to the processing units in the GPU through a general heterogeneous computing framework for CPU scheduling and execution.
2. According to the method for designing an Internet of Things gateway based on parallel computing according to claim 1, it is characterized in that: The storage structure uses memory database storage: For each type of data that needs to be processed in the database, a corresponding data table and a data table for storing the processed data are created to achieve orderly management and fast retrieval of data; For different processing units in the GPU and their corresponding kernel functions, a kernel function resource table is established to store and maintain the processing unit status in the GPU in real time.
3. According to the method for designing an Internet of Things gateway based on parallel computing according to claim 1, it is characterized in that: The overall task scheduling of the gateway adopts a multi-threaded design method: When the CPU is executing a task, The data collection thread writes the collected sensor layer data into the corresponding local database table in the gateway; The resource maintenance thread monitors the computing resource status of the GPU processor in real time and maintains the kernel function resource table; The task scheduling thread uses pattern matching algorithms and metadata analysis to monitor the matching between the kernel function resource table and the data table in real time. Once a match is found, the task execution thread is notified through the semaphore mechanism to execute the task processing flow. The task execution thread passes the data in the data table to the corresponding calculation kernel function for processing. After the data processing is completed, the GPU notifies the data reading thread through the interrupt mechanism to read back the processing result data and write it into the corresponding processed data table; The task response thread is responsible for reading the corresponding processed data table and forwarding the processed data to the corresponding communication interface.
4. According to the method for designing an Internet of Things gateway based on parallel computing according to claim 1, it is characterized in that: The hardware components include: The top layer is the network access layer, which is oriented to cloud servers or enterprise applications and integrates multiple communication interfaces, including optical fiber interface unit, RJ45 interface unit, WIFI interface unit, 4G / 5G interface unit and NBIOT interface unit; it supports dynamic addition and deletion of interface units in the gateway according to actual network access needs; The middle layer is the task processing layer, which adopts a heterogeneous mode combining CPU and GPU to collaboratively complete data processing, task scheduling and storage management tasks; The bottom layer is the data acquisition and interactive control layer, which faces the sensor layer and is responsible for data collection and the issuance of control commands. This layer integrates a variety of communication interfaces, including Bluetooth, Zigbee, LoRa, RS485, and RS232 data interface units, and supports adding and deleting interface units in the gateway according to the data access requirements of the sensor layer.
5. According to the method for designing an Internet of Things gateway based on parallel computing according to claim 4, it is characterized in that: In the task processing layer, the CPU processor and the GPU processor are connected via a PCIE high-speed bus.
6. According to the method for designing an Internet of Things gateway based on parallel computing according to claim 1, it is characterized in that: The software tasks are divided into CPU tasks and GPU tasks based on a preset division rule, The preset division rules are used to determine whether the software task is a computationally intensive task or a logic analysis or control task.
7. The method for designing an Internet of Things gateway based on parallel computing according to claim 1, characterized in that: The implementation process of this method is as follows: S1. List all the functional tasks that the software needs to implement according to the functions that the gateway needs to implement; S2. Divide the tasks into CPU tasks and GPU tasks according to preset rules; S3, design the corresponding CPU task processing program; S4. For GPU tasks, we further adopt a subdivision strategy to decompose complex computing tasks into computing subtasks with finer granularity. S5. Design the corresponding computing kernel function for GPU subtasks; S6, the kernel function is optimized and compiled and converted into a binary file executable by the GPU; S7. During the CPU program execution, the kernel function is sent to the processing unit in the GPU through the heterogeneous computing framework for CPU scheduling.
8. An Internet of Things gateway system based on parallel computing, characterized in that: It includes CPU task module and GPU task module; CPU task and GPU task are divided according to the functions that the gateway needs to realize and based on the preset division rules. The CPU tasks include the collection of sensor layer data and the issuance of control commands, the uploading and receiving of network layer data, as well as the overall task scheduling and logic control functions; The GPU tasks are computationally intensive tasks, including encryption and decryption, data filtering, data preprocessing, and edge computing; The GPU task module adopts a task subdivision strategy to further decompose the GPU task into computing subtasks and write a dedicated kernel function for each subtask; these kernel functions are optimized and compiled and converted into GPU executable binary files. During the initialization of the gateway program, the kernel functions are sent to the processing units in the GPU through a general heterogeneous computing framework for CPU scheduling and execution; The system specifically implements parallel computing of the Internet of Things gateway through the Internet of Things gateway design method based on parallel computing as described in any one of claims 1 to 7.
9. A device for implementing an Internet of Things gateway based on parallel computing, characterized in that: include: at least one memory and at least one processor; The at least one memory is used to store a machine-readable program; The at least one processor is used to call the machine-readable program to implement the method described in any one of claims 1 to 7.
10. A computer readable medium, characterized in that The computer readable medium stores computer instructions, and when the computer instructions are executed by a processor, the method according to any one of claims 1 to 7 is implemented.
