A heterogeneous real-time technology operating system kernel implementation method
By using a segmented task model and kernel modules to track task status in real time and dynamically update task priorities, the problem of implementing real-time technology on heterogeneous computing platforms in existing technologies has been solved, achieving more efficient task scheduling and real-time assurance.
Patent Information
- Application Number
- CN202610645087.0
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2026-05-11
- Publication Date
- 2026-07-31
AI Technical Summary
Existing technologies lack real-time operating system kernel implementation schemes for heterogeneous computing platforms that support accelerators. They cannot record the execution status and execution time of each stage of the task in real time, nor can they dynamically update task priorities and adjust the execution order, resulting in a discrepancy between theoretical analysis and actual operation.
Tasks are described using a segmented task model. The task status and time are tracked in real time by the operating system kernel module, the task priority is dynamically updated, and the task execution order is adjusted by the scheduler. This includes task modeling, real-time tracking by the kernel module, and dynamic scheduling based on real-time execution status.
It improves the execution efficiency and scheduling accuracy of heterogeneous real-time tasks, narrows the gap between theoretical analysis and actual operation, and enhances the system's real-time performance assurance capability in heterogeneous computing environments.
Smart Images
Figure CN122489277A_ABST
Abstract
Description
Technical Field
[0001] This invention relates to the field of task scheduling, and more particularly to an operating system kernel implementation method for heterogeneous real-time technology. Background Technology
[0002] As applications such as artificial intelligence inference, robot control, autonomous driving, industrial control, and unmanned system perception and decision-making increasingly demand higher requirements for computing performance and time-deterministic consistency, heterogeneous computing platforms supporting accelerators, such as CPU-GPU, CPU-FPGA, CPU-TPU, and CPU-NPU, have been widely used to support real-time tasks with strict deadline constraints. Compared to traditional real-time tasks that execute solely on the CPU, accelerator-supported tasks typically involve simultaneous host-side computation, data preparation, device-side transmission, asynchronous completion notification, and alternating execution of CPU and accelerator segments. These tasks exhibit stronger phased execution, asynchronicity, and resource contention, resulting in more complex response times and scheduling behavior.
[0003] In such systems, tasks often do not simply occupy a single processor core for continuous execution at the operating system level, but may switch between multiple stages. For example, a task might first complete preprocessing and driver calls on the CPU, then enter a stage waiting for the accelerator to complete, before being woken up and returning to the CPU to continue executing post-processing logic. Because this execution process spans CPU cores, accelerator devices, driver stacks, and interrupt handling paths, if traditional real-time scheduling and analysis methods for single-core or homogeneous multi-core processors are still used, it is easy to underestimate the overhead of blocking, suspension, queuing, and device access, resulting in discrepancies between theoretical analysis results and actual operating results.
[0004] However, most existing real-time scheduling research still focuses on traditional processor task models. Regarding the analysis of multi-segment execution and self-suspended tasks, Wen-Hung Huang and Jian-Jia Chen studied self-suspended real-time tasks under fixed-priority scheduling in *Self-suspension Real-Time Tasks under Fixed-Relative-Deadline Fixed-Priority Scheduling*, in *Design, Automation & Test in Europe Conference & Exhibition*, 2016. Pratyush Patel, Iljoo Baek, Hyoseung Kim, and Ragunathan Rajkumar further discussed related analytical issues in conjunction with the self-suspended model in *Analytical Enhancements and Practical Insights for MPCP with Self-Suspensions*, in *IEEE Real-Time and Embedded Technology and Applications Symposium (RTAS)*, 2018. This type of research provides a foundation for the timing analysis of segmented tasks, but its focus remains primarily on traditional CPU task models and their schedulability analysis.
[0005] Research on real-time scheduling and resource management for accelerators has begun to focus on real-time task execution on GPUs and heterogeneous platforms. Glenn A. Elliott, Bryan C. Ward, and James H. Anderson proposed a real-time GPU management framework in GPUSync: A Framework for Real-Time GPU Management, 2013 IEEE 34th Real-Time Systems Symposium. Shinpei Kato, Karthik Lakshmanan, Raj Rajkumar, and Yutaka Ishikawa designed a GPU scheduling mechanism for real-time multi-tasking environments from the device driver layer in TimeGraph: GPU Scheduling for Real-Time Multi-Tasking Environments, Proc. USENIX ATC, 2011. These works demonstrate that enhancing the management of accelerator tasks at the operating system or runtime level is crucial for improving the timing controllability of real-time tasks.
[0006] Furthermore, regarding task-level scheduling on heterogeneous platforms, Yuankai Xu, Tiancheng He, Ruiqi Sun, Yehan Ma, Yier Jin, and An Zou studied fixed-priority task scheduling in multi-CPU and multi-processor unit scenarios in SHAPE: Scheduling of Fixed-PriorityTasks on Heterogeneous Architectures with Multiple CPUs and Many PEs. In Proceedings of the IEEE / ACM International Conference on Computer-Aided Design, 2022; YechengXiang and Hyoseung Kim proposed a pipelined data-parallel CPU / GPU scheduling method for Multi-DNN Real-Time Inference in IEEE Real-Time Systems Symposium (RTSS), 2019; AnZou, Jing Li, Christopher Gill, and Xuan Zhang published RTGPU: Real-Time GPU Scheduling of Hard Deadline Parallel Tasks with Fine-Grain Utilization. The IEEE Transactions on Parallel and Distributed Systems, 2023, proposed a real-time GPU scheduling method for parallel tasks with hard deadlines. These studies have promoted the development of real-time computing supporting accelerators from the perspectives of task models, resource allocation, and scheduling strategies, but their focus is still largely on offline analysis, resource partitioning, or device-level scheduling strategies.
[0007] Existing Chinese patents, such as CN110308988A, disclose a dynamic scheduling method and system for heterogeneous computing platforms. This method selects an execution platform based on the performance and proximity value of computing nodes on different platforms to improve hardware resource utilization and algorithm performance. Such solutions primarily address the allocation between tasks and heterogeneous execution platforms, focusing on platform selection and scheduling decisions rather than the real-time task execution status tracking mechanism within the operating system kernel. Therefore, these patents do not yet address the following key issues: how to record the execution status and time of each stage of a task in real time at the kernel level; how to update the task's running profile based on events such as device completion, interrupt wake-up, and blocking unblocking; and how to dynamically update task priorities and drive the scheduler to adjust the execution order accordingly.
[0008] In summary, while existing technologies have addressed related issues from various perspectives, including self-suspended task analysis, GPU runtime management, heterogeneous platform resource allocation, response time analysis, and dynamic scheduling, a real-time technology implementation scheme that can be directly implemented in the operating system kernel for heterogeneous computing platforms supporting accelerators is still lacking. In particular, existing technologies have not yet formed an implementation system that organically combines kernel modules, execution status tracking, execution time statistics, dynamic priority updates, and scheduler linkage mechanisms. Therefore, there is an urgent need for a real-time technology operating system kernel implementation scheme for heterogeneous computing platforms supporting accelerators. This scheme should enable the development of kernel modules to track the execution status and execution time of tasks in real time, dynamically update task priorities based on their real-time execution status during task execution, and use a scheduler to adjust the task execution order. This would reduce the discrepancy between theoretical analysis and actual operation, and improve the system's real-time performance and engineering feasibility in heterogeneous computing environments. Summary of the Invention
[0009] In view of the above-mentioned deficiencies of the prior art, the technical problem to be solved by the present invention is how to design a real-time technology operating system kernel implementation scheme for heterogeneous computing platforms that support accelerators.
[0010] To achieve the above objectives, this invention provides an operating system kernel implementation method for heterogeneous real-time technology. The method comprises three steps: task modeling, real-time tracking of kernel modules, and dynamic scheduling based on real-time execution status. This improves the execution efficiency, scheduling accuracy, and system real-time performance of heterogeneous real-time tasks. Specifically, this invention addresses the alternating operation characteristics of tasks across CPU computing segments, waiting device segments, and accelerator execution segments by uniformly designing task timing parameters, execution status, and scheduling linkage relationships. This enables the scheduler to dynamically adjust the execution order based on the real-time status of the tasks.
[0011] Furthermore, it includes the following steps: Step 1: Perform task modeling for heterogeneous real-time systems, use a segmented task model to describe periodic real-time tasks, clarify the execution dependency between CPU computing segments and accelerator computing segments, decompose task response time and set real-time scheduling targets. Step 2: Develop an operating system kernel enhancement module to track the execution status and execution time of the task in real time during the CPU calculation phase, the waiting accelerator phase, the accelerator execution phase, and the completion callback recovery phase. Obtain the task's CPU running time through a high-precision time acquisition interface registered in the kernel, and build a task execution progress inference mechanism to recover the current execution phase of the task. Step 3: Dynamically calculate task priorities based on the real-time execution status of the tasks. Determine the priority sorting rules based on the number of remaining accelerator calculation segments, deadline margin, and task cycle. The kernel module submits the updated priorities to the scheduler, and the scheduler rearranges the ready queue and adjusts the task execution order according to the new priorities.
[0012] Furthermore, in step 1, the segmented task model is used to describe the real-time task of the i-th cycle. Its task parameters can be expressed as:
[0013] in, This represents the execution time of the j-th CPU computation segment. This represents the execution time of the j-th accelerator computation segment. Indicates the task cycle. Indicates a relative deadline. Indicates the number of accelerator compute segments included in the task; The execution dependency relationship is that each CPU segment waits for the previous accelerator segment to complete, and each accelerator segment waits for the previous CPU segment to complete, which is equivalent to a multi-segment self-suspended task model.
[0014] Furthermore, in step 1, the overall task response time is composed of the response times of each computation segment:
[0015] in, This represents the response time of the j-th CPU computation segment. Let represent the response time of the j-th accelerator computation segment; a sufficient condition for the system to satisfy real-time performance is that the response time of all tasks is less than their deadline, i.e., .
[0016] Furthermore, in step 2, the operating system kernel enhancement module includes a CPU time tracking module, a procfs-based user-mode interface system, and a task execution status inference module; the overall workflow is: user task → scheduler → kernel module → CPU time acquisition → priority update → scheduling execution.
[0017] Furthermore, in step 2, high-precision time acquisition is achieved through a kernel module: a task tracing interface is registered in the kernel, and kernel functions are used to obtain the CPU execution time of the task and provide a user-mode access interface. The key interfaces include: (1) / proc / trace_pid: registering the task ID to be monitored; (2) / proc / trace: outputting the cumulative CPU execution time of the task; the time acquisition method is to obtain the user-mode execution time and kernel-mode execution time for each task thread, and calculate: =Current cumulative CPU time - Last recorded time This is used to characterize the actual amount of task execution within the current scheduling window.
[0018] Furthermore, in step 2, the task execution progress inference mechanism is as follows: based on the segmented task model defined in step 1, the CPU computation segment execution time is... Let the cumulative CPU execution time of the task within the current scheduling window be . The current execution segment number is determined by comparing it with the worst-case execution time of the CPU segment. satisfy:
[0019] That is, the task is currently in the first stage. Each CPU computing segment or its subsequent accelerator stage.
[0020] Furthermore, in step 3, for the task The kth assignment Record its release time as Then its absolute deadline is:
[0021] The kernel module maintains the current execution state for each job. Current calculation segment number and the number of accelerator computing segments completed ;in, At least the states include ready, CPU execution, waiting for accelerator, accelerator completion and scheduling, and completed. The kernel module updates these states in real time when events such as task release, CPU computation completion, task submission to accelerator execution, accelerator completion interruption, task wake-up, or task blocking occur in the system. , and This is to reflect the phased changes of the task during its actual operation.
[0022] Furthermore, in step 3, dynamic priority calculation parameters are constructed based on the real-time execution status of the task, and the remaining number of accelerator computation segments for the task at time t is denoted as... The deadline margin is Then we have:
[0023] in, Used to characterize the degree of need for accelerator resources and scheduling opportunities in the subsequent mission. These parameters are used to characterize the current time urgency of the task; based on the above parameters, the dynamic priority of the task is calculated. Preferably, the task execution order is determined by lexicographical comparison based on priority keywords, wherein... The larger the task, the higher its priority; when When they are the same, Smaller tasks have higher priority; when both are equal... Smaller tasks have higher priority.
[0024] Furthermore, in step 3, the kernel module submits the updated priority results to the scheduler; the scheduler reorders the ready queue according to the new priorities, thereby adjusting the task execution order and selecting the new highest priority task for execution.
[0025] The present invention has the following technical effects: (1) Stronger kernel-level state awareness: This invention directly tracks the execution status and execution time of tasks through kernel modules, which can more realistically reflect the actual running situation of tasks when switching between CPU and accelerator, and provide a more accurate basis for real-time scheduling.
[0026] (2) More timely scheduling decisions: This invention does not rely on fixed priorities, but dynamically updates task priorities based on the real-time execution status of tasks and drives the scheduler to adjust the task execution order, so that task scheduling can better adapt to the state changes during system operation.
[0027] (3) Better engineering implementation: This invention implements real-time technology around the operating system kernel, which can be combined with existing drivers, schedulers and heterogeneous computing execution frameworks, and has better system integration capabilities and practical deployment value.
[0028] The following will further explain the concept, specific structure, and technical effects of the present invention in conjunction with the accompanying drawings, so as to fully understand the purpose, features, and effects of the present invention. Attached Figure Description
[0029] Figure 1 This is a schematic diagram of a processor time usage tracking kernel module and a task execution progress tracking module according to a preferred embodiment of the present invention; Figure 2 This is a schematic diagram of a preferred embodiment of the present invention, which describes a method for dynamically updating task priorities based on the real-time execution status of tasks and adjusting the task execution order using a scheduler. Detailed Implementation
[0030] The following description, with reference to the accompanying drawings, illustrates several preferred embodiments of the present invention to make its technical content clearer and easier to understand. The present invention can be embodied in many different forms, and the scope of protection of the present invention is not limited to the embodiments mentioned herein.
[0031] In the accompanying drawings, components with the same structure are indicated by the same numerical designation, and components with similar structures or functions are indicated by similar numerical designations. The dimensions and thicknesses of each component shown in the drawings are arbitrary, and the present invention does not limit the dimensions and thicknesses of each component. To make the illustrations clearer, the thickness of some components has been appropriately exaggerated in the drawings.
[0032] This invention provides a real-time operating system kernel implementation method for heterogeneous computing platforms supporting accelerators, comprising the following three steps. This method revolves around three core aspects: task modeling, real-time tracking of kernel modules, and dynamic scheduling based on real-time execution status, aiming to improve the execution efficiency, scheduling accuracy, and system real-time performance of heterogeneous real-time tasks.
[0033] Specifically, this invention addresses the operational characteristics of tasks that alternate between CPU computation, waiting device, and accelerator execution segments. It unifies the design of task timing parameters, execution states, and scheduling linkages, enabling the scheduler to dynamically adjust the execution order based on the real-time status of tasks. This includes the following three steps: Step 1: Task Modeling for Heterogeneous Real-Time Systems 1.1.1) Task Model Definition A segmented task model is used to describe the real-time task in the i-th cycle. Its task parameters can be expressed as:
[0034] in, This represents the execution time of the j-th CPU computation segment. This represents the execution time of the j-th accelerator computation segment. Indicates the task cycle. Indicates a relative deadline. This indicates the number of accelerator compute segments included in the task.
[0035] 1.1.2) Execution Dependency Modeling
[0036] Task execution follows a strict sequential dependency relationship: (1) Each CPU segment must wait for the previous accelerator segment to complete; (2) Each accelerator segment must wait for the previous CPU segment to complete.
[0037] This execution mode is equivalent to a multi-segmented self-suspension model.
[0038] 1.2) Decomposition of Scheduling Objectives and Task Response Time
[0039] The overall task response time is composed of the response times of each computation segment:
[0040] in, This represents the response time of the j-th CPU computation segment. Let represent the response time of the j-th accelerator computation segment; a sufficient condition for the system to satisfy real-time performance is that the response time of all tasks is less than their deadline, i.e., .
[0041] Step 2: Track the execution status and execution time of tasks in real time within the kernel module.
[0042] 2.1) Kernel-level real-time scheduling framework
[0043] To achieve runtime scheduling control, this invention designs an operating system kernel enhancement module, such as... Figure 1 As shown, it includes: CPU time tracking module, procfs-based user-space interface system, and task execution status inference module.
[0044] The overall workflow is as follows: User task → Scheduler → Kernel module → CPU time acquisition → Priority update → Schedule execution.
[0045] 2.2) Task execution time tracking mechanism
[0046] 2.2.1) Limitations of Standard Interfaces
[0047] Traditional Linux scheduling status interfaces (such as / proc / [pid] / stat) have low time precision (milliseconds), which cannot meet the requirements of real-time scheduling.
[0048] This invention achieves high-precision time acquisition through a kernel module: a task tracing interface is registered in the kernel, kernel functions are used to obtain the CPU runtime of tasks, and a user-mode access interface is provided.
[0049] Key interfaces include: (1) / proc / trace_pid: Registers the task IDs that need to be monitored; (2) / proc / trace: Outputs the cumulative CPU execution time of the task.
[0050] 2.2.3) Time Acquisition Method
[0051] For each task thread, obtain the user-mode execution time and kernel-mode execution time, and calculate: =Current cumulative CPU time - Last recorded time This is used to characterize the actual amount of task execution within the current scheduling window.
[0052] 2.2.4) Task execution progress estimation
[0053] After obtaining the task's CPU execution time, this invention further constructs a task execution progress inference mechanism to recover the task's execution phase in the segmented model from time information, thereby providing accurate state input for subsequent scheduling decisions. According to the segmented task model defined in step 1, its CPU computation segment execution time is... Let the cumulative CPU execution time of the task within the current scheduling window be . The current execution segment number is determined by comparing it with the worst-case execution time of the CPU segment. satisfy:
[0054] That is, the task is currently in the first stage. Each CPU computing segment or its subsequent accelerator stage.
[0055] Step 3: Based on the real-time execution status of the tasks, dynamically update the task priorities and use the scheduler to adjust the task execution order.
[0056] 3.1) Definition of job timing parameters and state variables
[0057] For the task The kth assignment Record its release time as Then its absolute deadline is:
[0058] The kernel module maintains the current execution state for each job. Current calculation segment number and the number of accelerator computing segments completed .in, It includes at least the ready state, CPU execution state, waiting for accelerator state, accelerator completed and waiting to be scheduled state, and completed state.
[0059] 3.2) Task state transition
[0060] like Figure 2 As shown, when events such as task release, CPU computation segment completion, task submission to accelerator execution, accelerator completion interruption, task wake-up, or task blocking occur in the system, the kernel module updates in real time. , and This is to reflect the phased changes of the task during its actual operation.
[0061] 3.3) Dynamic Priority Calculation
[0062] Dynamic priority calculation parameters are constructed based on the real-time execution status of the task. Let the number of remaining accelerator computation segments for the task at time t be denoted as . The deadline margin is Then we have:
[0063] in, Used to characterize the degree of need for accelerator resources and scheduling opportunities in the subsequent mission. These parameters are used to characterize the current time urgency of the task. Dynamic task priority is calculated based on these parameters. Preferably, the task execution order is determined by a lexicographical comparison based on priority keywords, wherein... The larger the task, the higher its priority; when When they are the same, Smaller tasks have higher priority; when both are equal... Smaller tasks have higher priority.
[0064] 3.4) Scheduler linkage adjustment
[0065] The kernel module submits the updated priority results to the scheduler; the scheduler reorders the ready queue according to the new priorities, thereby adjusting the task execution order and selecting the new highest priority task to execute.
[0066] The preferred embodiments of the present invention have been described in detail above. It should be understood that those skilled in the art can make numerous modifications and variations based on the concept of the present invention without creative effort. Therefore, all technical solutions that can be obtained by those skilled in the art based on the concept of the present invention through logical analysis, reasoning, or limited experimentation on the basis of existing technology should be within the scope of protection defined by the claims.
Claims
1. A method for implementing an operating system kernel for heterogeneous real-time technology, characterized in that, The invention comprises three steps: task modeling, real-time tracking of kernel modules, and dynamic scheduling based on real-time execution status. These steps aim to improve the execution efficiency, scheduling accuracy, and real-time performance of heterogeneous real-time tasks. Specifically, this invention addresses the operational characteristics of tasks that alternate between CPU computing segments, waiting device segments, and accelerator execution segments. It unifies the design of task timing parameters, execution status, and scheduling linkage relationships, enabling the scheduler to dynamically adjust the execution order based on the real-time status of the tasks.
2. The operating system kernel implementation method for heterogeneous real-time technology as described in claim 1, characterized in that, Includes the following steps: Step 1: Perform task modeling for heterogeneous real-time systems, use a segmented task model to describe periodic real-time tasks, clarify the execution dependency between CPU computing segments and accelerator computing segments, decompose task response time and set real-time scheduling targets. Step 2: Develop an operating system kernel enhancement module to track the execution status and execution time of the task in real time during the CPU calculation phase, the waiting accelerator phase, the accelerator execution phase, and the completion callback recovery phase. Obtain the task's CPU running time through a high-precision time acquisition interface registered in the kernel, and build a task execution progress inference mechanism to recover the current execution phase of the task. Step 3: Dynamically calculate task priorities based on the real-time execution status of the tasks. Determine the priority sorting rules based on the number of remaining accelerator calculation segments, deadline margin, and task cycle. The kernel module submits the updated priorities to the scheduler, and the scheduler rearranges the ready queue and adjusts the task execution order according to the new priorities.
3. The operating system kernel implementation method for heterogeneous real-time technology as described in claim 2, characterized in that, In step 1, the segmented task model is used to describe the real-time task of the i-th cycle. Its task parameters can be expressed as: in, This represents the execution time of the j-th CPU computation segment. This represents the execution time of the j-th accelerator computation segment. Indicates the task cycle. Indicates a relative deadline. Indicates the number of accelerator compute segments included in the task; The execution dependency relationship is that each CPU segment waits for the previous accelerator segment to complete, and each accelerator segment waits for the previous CPU segment to complete, which is equivalent to a multi-segment self-suspended task model.
4. The operating system kernel implementation method for heterogeneous real-time technology as described in claim 3, characterized in that, In step 1, the overall task response time is composed of the response times of each computation segment: in, This represents the response time of the j-th CPU computation segment. Let represent the response time of the j-th accelerator computation segment; a sufficient condition for the system to satisfy real-time performance is that the response time of all tasks is less than their deadline, i.e., .
5. The operating system kernel implementation method for heterogeneous real-time technology as described in claim 4, characterized in that, In step 2, the operating system kernel enhancement module includes a CPU time tracking module, a procfs-based user-space interface system, and a task execution status inference module; the overall workflow is: user task → scheduler → kernel module → CPU time acquisition → priority update → scheduling execution.
6. The operating system kernel implementation method for heterogeneous real-time technology as described in claim 5, characterized in that, In step 2, high-precision time acquisition is implemented through the kernel module: a task tracing interface is registered in the kernel, kernel functions are used to obtain the CPU runtime of the task and provide a user-mode access interface; Key interfaces include: (1) / proc / trace_pid: registers the task ID to be monitored; (2) / proc / trace: outputs the cumulative CPU execution time of the task; the time collection method is to obtain the user-mode execution time and kernel-mode execution time for each task thread, and calculate: =Current cumulative CPU time - Last recorded time This is used to characterize the actual amount of task execution within the current scheduling window.
7. The operating system kernel implementation method for heterogeneous real-time technology as described in claim 6, characterized in that, In step 2, the task execution progress inference mechanism is as follows: based on the segmented task model defined in step 1, the CPU computation segment execution time is... Let the cumulative CPU execution time of the task within the current scheduling window be . The current execution segment number is determined by comparing it with the worst-case execution time of the CPU segment. satisfy: That is, the task is currently in the first stage. Each CPU computing segment or its subsequent accelerator stage.
8. The operating system kernel implementation method for heterogeneous real-time technology as described in claim 7, characterized in that, In step 3, for the task The kth assignment Record its release time as Then its absolute deadline is: The kernel module maintains the current execution state for each job. Current calculation segment number and the number of accelerator computing segments completed ;in, At least the states include ready, CPU execution, waiting for accelerator, accelerator completion and scheduling, and completed. The kernel module updates these states in real time when events such as task release, CPU computation completion, task submission to accelerator execution, accelerator completion interruption, task wake-up, or task blocking occur in the system. , and This is to reflect the phased changes of the task during its actual operation.
9. The operating system kernel implementation method for heterogeneous real-time technology as described in claim 8, characterized in that, In step 3, dynamic priority calculation parameters are constructed based on the real-time execution status of the task, and the remaining number of accelerator computation segments for the task at time t is denoted as . The deadline margin is Then we have: in, Used to characterize the degree of need for accelerator resources and scheduling opportunities in the subsequent mission. These parameters are used to characterize the current time urgency of the task; based on the above parameters, the dynamic priority of the task is calculated. Preferably, the task execution order is determined by lexicographical comparison based on priority keywords, wherein... The larger the task, the higher its priority; when When they are the same, Smaller tasks have higher priority; when both are equal... Smaller tasks have higher priority.
10. The operating system kernel implementation method for heterogeneous real-time technology as described in claim 9, characterized in that, In step 3, the kernel module submits the updated priority results to the scheduler; the scheduler reorders the ready queue according to the new priorities, thereby adjusting the task execution order and selecting the new highest priority task to execute.