A burst task elastic resource pool scheduling method and system for a network scheduling system

Abstract

The present application relates to the technical field of algorithm network fusion and industrial edge real-time scheduling, and particularly relates to a burst task elastic resource pool scheduling method and system for an algorithm network scheduling system, comprising the following steps: based on a burst task entering a core scheduling layer, performing access normalization identification, combining a load level, an estimated execution time length, a network data dependency state and feature integrity into a burst task access description, and writing into a to-be-scheduled burst task queue; based on the burst task access description, a current idle window of a real-time exclusive core domain, a dynamic safety time boundary and an available resource state of an elastic pool dedicated core domain, obtaining a dual-domain routing resource plan. The present application generates a dual-domain routing resource plan, so that a lightweight, short-time and network data ready task reuses a real-time exclusive core domain idle window, and other tasks are forced to enter an elastic pool dedicated core domain, thereby giving consideration to hard real-time determinacy and resource utilization.

Description

Technical Field

[0001] This invention relates to the field of computing network convergence and industrial edge real-time scheduling technology, and in particular to a method and system for scheduling sudden tasks with elastic resource pools for computing network scheduling systems. Background Technology

[0002] The computing network scheduling system refers to a scheduling system that uniformly orchestrates, allocates, and reclaims computing and network resources. Computing resources include real-time dedicated core domains, elastic pool dedicated core domains, system general core domains, CPU time slices, large page memory shards, and cache partitions. Network resources include network micro-time slots, network data ready states, network congestion states, TSN transmission windows, or software traffic shaping windows. The system comprises a service layer, a core scheduling layer, and a computing network resource layer. The core scheduling layer is located between the service layer and the computing network resource layer and is used to receive periodic hard real-time tasks, local short-term burst tasks, and edge computing network remote burst tasks, and to coordinate the scheduling of computing and network resources.

[0003] In industrial settings such as edge smart gateways, robot controllers, and power edge nodes, periodic hard real-time tasks need to be started and executed stably according to a fixed cycle, requiring high determinism in scheduling latency, cache hit rate, memory access, and network data arrival. Existing solutions typically use static full-core reservation, CPU affinity binding, or independent resource pools to coarsely isolate real-time tasks from bursty tasks. While this approach can reduce some preemption interference at the operating system level, the idle windows formed by the dedicated real-time core domain between the execution of periodic hard real-time tasks often cannot be safely reused, resulting in long-term idle computing resources. At the same time, reserving full cores, fixed bandwidth, or independent memory space separately for bursty tasks can also lead to waste when the resource configuration is too large and blocking timeouts when the configuration is too small.

[0004] Existing technologies generally overlook microarchitecture-level hidden interference. Even if bursty tasks run on other processor cores, they may still affect the real-time dedicated core domain through last-level cache contention, memory bandwidth contention, DMA transfers, and non-real-time interrupts, causing long-tail latency fluctuations in periodic hard real-time tasks. Existing CPU affinity binding or ordinary operating system isolation mechanisms are insufficient to cut off such interference paths at the hardware level. For computing and network convergence scenarios, existing computing power scheduling and network scheduling are often disconnected: the computing power side only focuses on whether the CPU is idle, and the network side only focuses on whether data is transmitted, lacking a unified spatiotemporal matching mechanism. When network data fails to arrive before the start of the CPU time slice, the allocated computing power resources will idle. After the bursty task ends, the release of CPU time slices, large page memory slices, network micro-slots, and cache partitions may be delayed, causing hidden resource contention for subsequent tasks.

[0005] Therefore, existing technologies lack a scheduling method that can simultaneously consider the determinism of periodic hard real-time tasks and the elastic bearing capacity of bursty tasks in a computing network scheduling system. Summary of the Invention

[0006] This invention provides a method and system for scheduling bursty tasks using an elastic resource pool in a computing network scheduling system.

[0007] A method for scheduling bursty tasks using an elastic resource pool in a computing network scheduling system includes the following steps:

[0008] Based on the sudden tasks entering the core scheduling layer, admission normalization identification is performed. The load level, estimated execution time, network data dependency status and feature integrity are combined into a sudden task admission description and written into the queue of sudden tasks to be scheduled.

[0009] Based on the sudden task admission description, the current idle window of the real-time dedicated core domain, the dynamic security time boundary, and the available resource status of the elastic pool dedicated core domain, obtain the dual-domain routing resource plan;

[0010] Based on the dual-domain routing resource plan, in the first scheduling domain, a two-level scheduler driven by a hardware timer runs the first scheduling domain idle window reuse task in the periodic hard real-time task idle window, and forcibly reclaims it when the dynamic safety time boundary is reached.

[0011] In the second scheduling domain, elastic pool tasks are run based on the elastic resource pool consisting of CPU time slices, large page memory slices, network micro-time slots, and cache partitions, and the scheduling results of the elastic resource pool are obtained.

[0012] The beneficial effects of this invention are:

[0013] This invention synthesizes a burst task admission description by combining load level, estimated execution duration, network data dependency status, and feature integrity, and generates a dual-domain routing resource plan accordingly. This allows lightweight, short-term tasks with readily available network data to reuse the real-time dedicated core domain idle window, while other tasks are forced to enter the elastic pool's dedicated core domain, balancing hard real-time determinism with resource utilization.

[0014] This invention uses a hardware timer in the first scheduling domain to drive a two-level scheduler and a dynamic safety time boundary to limit the execution of bursty tasks and forcibly reclaim them when the boundary is reached. In the second scheduling domain, a flexible resource pool is formed by combining CPU time slices, large page memory shards, network micro-time slots and cache partitions. Delayed retries and CPU time slice handover are performed on network-blocking tasks to avoid idle computing power and delayed resource release. Attached Figure Description

[0015] To more clearly illustrate the technical solutions in this 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 for this invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0016] Figure 1 This is a block diagram of the overall architecture of the computing network scheduling system according to Embodiment 1 of the present invention;

[0017] Figure 2 This is a schematic diagram of the composition and resource isolation of the emergency task elastic resource pool in Embodiment 1 of the present invention;

[0018] Figure 3 This is a schematic diagram of the method flow of Embodiment 1 of the present invention;

[0019] Figure 4 This is a schematic diagram of the system modules in Embodiment 2 of the present invention. Detailed Implementation

[0020] The present invention will now be described in detail with reference to the accompanying drawings and specific embodiments. For some well-known technologies, those skilled in the art may also use other alternative methods to implement the invention. Moreover, the accompanying drawings are only for more specific description of the embodiments and are not intended to specifically limit the present invention.

[0021] Example 1

[0022] like Figures 1-3 As shown, a method for scheduling bursty tasks using an elastic resource pool in a computing network scheduling system includes the following steps:

[0023] S1. Perform admission normalization identification on the sudden tasks entering the core scheduling layer, and synthesize their load level, estimated execution time, network data dependency status and feature integrity into a sudden task admission description, and write the sudden task admission description into the queue of sudden tasks to be scheduled.

[0024] S11. After receiving a task to be processed, the core scheduling layer first reads the task submission information and running attribute information of the task. The running attribute information includes at least whether the task has a fixed running cycle, whether the task is triggered by an external event, and whether the task is long-term resident. For tasks with a fixed running cycle, triggered by a periodic clock or industrial control cycle, and requiring long-term resident operation, they are determined to be periodic hard real-time tasks. For tasks without a fixed running cycle, triggered by local computing power requests, edge computing network requests, remote events, network packet arrivals, or temporary control instructions, and releasing running resources after completion, they are determined to be short-term burst tasks.

[0025] The task attribute determination result is represented as follows: ;in, Indicates the first The task attribute identification results of each task entering the core scheduling layer; The values ​​include periodic hard real-time tasks and short-term burst tasks; This represents a function for determining task attributes. Indicates the first The runtime attribute of a task, when the task has a fixed periodic triggering relationship; If the periodic attribute is valid, then the periodic attribute is invalid. Indicates the first The triggering method attribute for each task specifies when it is triggered by an external event, network packet, local temporary request, or edge computing network request. The event is valid; Indicates the first The persistent nature of a task; when a task needs to remain persistent and execute continuously. This is valid for permanent attributes.

[0026] The task attribute discrimination function is determined according to the following logic:

[0027] ;

[0028] in, This indicates the result of the task attribute determination; Indicates runtime attributes; This indicates the triggering method attribute; This indicates a permanent attribute.

[0029] when When it is a periodic hard real-time task, it indicates that the task belongs to the main task in the real-time dedicated kernel domain that needs to be deterministically guaranteed. It will not enter the subsequent emergency task admission normalization identification process, but will instead be handled by the hard real-time task queue of the real-time dedicated kernel domain; when When a short-term emergency task is identified, an emergency task identification result is generated. The emergency task identification result shall at least record the task identifier, trigger source, submission time and task attribute discrimination result of the short-term emergency task.

[0030] S12, the core scheduling layer determines the short-term burst task to be identified based on the burst task identification result, and reads the resource requirement declaration of the short-term burst task, the historical resource usage record of similar tasks, the resource configuration information of the task image or execution code, and the resource requirement range given by the task submission end; then, it normalizes the CPU usage requirement, memory usage requirement, and network bandwidth usage requirement respectively, so that resource requirements of different dimensions can be mapped to a unified load level system; the load level system is set as lightweight, medium, and heavy, where lightweight is used to represent tasks with low resource usage and suitable for short-term operation in the real-time dedicated kernel domain idle window, and medium and heavy are used to represent tasks with high resource usage or strong continuous operation requirements.

[0031] The CPU load sub-level, memory load sub-level, and network load sub-level are represented as follows:

[0032] ;

[0033] ;

[0034] ;

[0035] in, Indicates the first CPU load sub-levels for short-duration burst tasks; Indicates the first Memory load sub-levels for short-duration burst tasks; Indicates the first A network load sub-level for short-term burst tasks; Represents a hierarchical mapping function; Indicates the first Normalized CPU usage requirements of a short-duration burst task; Indicates the first Normalized value of memory usage requirements for a short-lived burst task; Indicates the first Normalized value of network bandwidth usage requirements for a short-term, sudden task; and These represent the threshold values ​​for judging CPU usage demand from light to medium and from medium to heavy, respectively. and These represent the thresholds for judging memory usage requirements from light to medium and from medium to heavy, respectively. and These represent the threshold values ​​for judging network bandwidth usage from light to medium and from medium to heavy, respectively.

[0036] Hierarchical mapping function Represented as:

[0037] ;

[0038] in, This represents the normalized value of the demand for any type of resource. This indicates the threshold for judging whether a resource is lightweight or medium-weight. This indicates the threshold for judging whether a resource is of medium or heavy intensity.

[0039] Independent threshold groups are established for CPU usage, memory usage, and network bandwidth usage. First, a batch of typical short-duration burst tasks are run in a standard operating environment, recording their CPU usage, memory usage, network bandwidth usage, completion time, and whether they cause scheduling jitter for periodic hard real-time tasks. Then, combining the minimum idle window of the real-time dedicated core domain, the dynamic safety time boundary, the available resource scale of the elastic pool dedicated core domain, and the maximum allowable latency fluctuation of hard real-time tasks, the upper limit of resource usage for lightweight tasks to safely enter the first scheduling domain's idle window for reuse is determined. This upper limit is used as the resource limit. Continue to stress test sudden tasks or analyze their continuous time slice usage, memory fragment usage, network micro-slot usage, and resource release time based on historical operation records. When a certain resource usage level clearly requires continuous use of multiple CPU time slices, large page memory fragments, or network micro-slots in the elastic pool's dedicated core domain, or when its operation will significantly increase the queuing time of subsequent sudden tasks, that resource usage level is determined as [a certain level of resource usage]. .

[0040] When multiple load sub-levels are inconsistent, to avoid underestimating the resource consumption risk of sudden tasks, a conservative expansion and classification method is adopted to determine the load level of the short-term sudden task, represented as follows:

[0041] ;

[0042] in, Indicates the first The load level of a short-term, sudden task; This indicates that the highest level is selected according to the order of rank; Indicates the CPU load sub-level; Indicates the memory load sublevel; This indicates the network load sub-level; the order of the levels is: lightweight is lower than medium, and medium is lower than heavy.

[0043] When a short-lived burst task has low CPU usage but high memory or network bandwidth usage, it will not be misjudged as a lightweight task, thus avoiding its incorrect configuration as a first-schedule domain idle window reuse task and reducing the risk of it indirectly interfering with periodic hard real-time tasks.

[0044] During the operation of short-term burst tasks, the actual CPU usage, memory usage, and network bandwidth usage can be monitored according to a preset sampling period. When any resource usage indicator exceeds the current level threshold for multiple consecutive sampling periods, the load level of the short-term burst task is increased. When all resource usage indicators are below the current level threshold for multiple consecutive sampling periods, the load level of the short-term burst task is decreased, and the updated load level is written back to the corresponding burst task admission description.

[0045] S13, after determining the load level of a short-term burst task, the core scheduling layer continues to read the task type, the longest running time declared by the task submitter, the historical execution records of similar tasks in the standard operating environment, and the completion time records of similar tasks in the current computing network schedule. The standard operating environment refers to a reference operating environment obtained under preset CPU frequency, preset memory bandwidth, preset network bandwidth, and preset cache isolation conditions. Specifically, it first selects a processor, memory, network card, TSN switch, or ordinary network link consistent with the actual deployment environment as a calibration platform, and disables mechanisms that cause execution time fluctuations, such as dynamic frequency adjustment, automatic sleep, and unnecessary interrupt migration, to fix the CPU frequency at the industrial standard. The site allows for long-term stable operation of certain frequency points. Based on the resource isolation requirements of real-time dedicated core domains, elastic pool dedicated core domains, and general core domains, fixed memory bandwidth limits and fixed network bandwidth limits are allocated to the standard operating environment. Memory bandwidth is divided according to NUMA nodes, memory controllers, or memory access quotas, while network bandwidth is divided according to TSN micro-slots, VLAN priorities, or software traffic shaping windows. Finally, a preset cache isolation state is set, which binds independent cache partitions to different core domains, ensuring that short-term burst tasks can only use the cache partition consistent with their subsequent actual scheduling domain during testing. The estimated execution duration is used to determine whether the short-term burst task can fall within the current idle window after deducting the dynamic security time boundary.

[0046] The estimated execution time for short-term emergency tasks is expressed as follows:

[0047] ;

[0048] in, Indicates the first The estimated execution time of a short-term emergency task; This indicates taking the maximum value; Indicates the first A short-duration, contingent task is defined by the maximum runtime declared by the task submitter. Indicates the first Reference completion time corresponding to the historical execution record of a short-term emergency task under standard operating conditions; Indicates the relationship with the first The completion time reference value for a short-term emergency task is similar to that of other tasks. This represents the execution time safety compensation amount, used to compensate for execution time fluctuations caused by different hardware states, cache states, memory states, or network states. First, multiple trial runs are conducted on similar short-term burst tasks, recording their stable completion time under preset CPU frequency, preset memory bandwidth, preset network bandwidth, and preset cache isolation states. Then, the completion time is recorded after being affected by cache hit changes, memory access fluctuations, network data arrival offsets, context switching time, and resource reclamation time during actual scheduling. Subsequently, the deviation of the actual completion time from the standard completion time is used as the basis for candidate compensation, and extreme abnormal samples that are obviously caused by hardware anomalies, interrupt storms, or network failures are removed.

[0049] When there is a discrepancy between the historical execution record and the longest running time declared by the task submitter, the core scheduling layer selects the result that is no less than the larger of the two as the base value for the estimated execution time, and then combines it with the completion time and execution time safety compensation amount of similar tasks to obtain the final estimated execution time. This can prevent the sudden task submitter from underestimating the running time, causing the short-term sudden task to be incorrectly admitted to the idle window of the first scheduling domain.

[0050] When a short-term, emergency task lacks historical execution records, the determination should be based on the task type and the completion time of similar tasks. and will and The larger one is used as the base value for the estimated execution time; when the longest running time declared by the task submitter, historical execution records, and completion time of similar tasks cannot be obtained, it is determined that the estimated execution time of the short-term sudden task cannot be effectively determined, and the feature integrity is marked as incomplete in subsequent processes.

[0051] A network micro-slot refers to a fine-grained network transmission time window pre-divided for data reception or transmission of bursty tasks in computing network scheduling. It is a small time segment corresponding to the CPU time slice on the network side. In this invention, network micro-slots are mainly used to solve the problem that computing power has been allocated but network data has not yet arrived. When a short-term bursty task relies on remote data from the edge computing network, data reception from the TSN network, or data writing by the network card DMA, it will not only allocate a CPU time slice, but also match a network micro-slot that can complete data reception before CPU execution. If the task is configured as a task that reuses the idle window of the first scheduling domain, its network micro-slot must be earlier than or at least guaranteed to occur when the CPU is idle. Before the data slice begins, data readiness is ensured to avoid wasting valuable idle windows in the real-time dedicated core domain due to network waiting. If the task is configured as a second scheduling domain elastic pool task, the network micro-slot is used in conjunction with CPU time slices, large page memory slices, and cache partitions in the elastic pool dedicated core domain to form an elastic resource pool scheduling arrangement. When network data fails to become ready within the corresponding network micro-slot, the task is marked as network blocked, preventing it from being dequeued in the first scheduling domain, or it is placed in a delayed retry queue in the second scheduling domain. The CPU time slice that has not yet been used is then transferred to other tasks with ready network data or purely local computation tasks, thereby avoiding CPU idling and improving the utilization of computing network resources.

[0052] S14, the core scheduling layer reads the input data source and prerequisite data dependency of the short-term burst task based on the burst task identification result; when the short-term burst task needs to wait for data sent by the remote node of the edge computing network, data transmitted by the TSN switch according to the scheduled micro-time slot, or data written to memory by the local network card through DMA, it is determined that the short-term burst task has network data dependency; when the short-term burst task only uses the local existing data or can be executed without external data, it is determined that the short-term burst task has no network data dependency and is marked as a pure local computing burst task.

[0053] Network data dependencies are represented as follows: ;in, Indicates the first Does a short-term, emergency task depend on network data? Indicates the first Does a short-term, sudden task rely on remote data from the edge computing network? Indicates the first Does a short burst of tasks rely on TSN network micro-slot data reception? Indicates the first Does a short-duration burst task rely on the local network card DMA to receive data? Represents logic. When , , If any one of them is true, If true, it means that the short-term, emergency task has a network data dependency.

[0054] When a short-term burst task has a network data dependency, the core scheduling layer reads the corresponding network micro-slot reservation status, the network card DMA receive status register, or the data ready flag in memory to obtain the network data dependency status. The network data dependency status is set as follows: network data ready, network data in reservation, network data blocked, network data unknown, and pure local computation. For data that depends on TSN network micro-slots, if the corresponding network micro-slot has been reserved and is expected to be received before the start of the CPU time slice, the network data dependency status is network data ready or network data in reservation. If the corresponding network micro-slot has not been successfully reserved or the expected arrival time has passed without receiving data, the network data dependency status is network data blocked. If the network micro-slot reservation status, the network card DMA receive status register, or the data ready flag cannot be read, the network data dependency status is network data unknown.

[0055] Network data dependency state is represented as: ;in, Indicates the first Network data dependency status for a short-term, sudden task; This represents a function to determine network data dependency states. Indicates the first Does a short-term, emergency task depend on network data? Indicates the first The network micro-slot reservation status corresponding to a short-term emergency task; Indicates the first The DMA receive status register read results corresponding to each short-term burst task; This indicates the result of reading the data ready flag in memory.

[0056] Furthermore, the network data dependency state discriminant function is expressed as:

[0057] ;

[0058] in, Indicates the network data dependency state; Indicates whether there is a network data dependency; Indicates the status of network micro-slot reservations; This indicates the result of reading the DMA receive status register of the network card; This indicates the result of reading the data ready flag in memory; Indicates a logical OR relationship; Represents logical AND relation.

[0059] S15, after obtaining the load level, estimated execution time, and network data dependency status, the core scheduling layer performs integrity checks on the above three fields. The integrity check is not simply to determine whether the field is empty, but to simultaneously determine whether the field can be effectively determined, whether it is within a preset trusted range, and whether there are logical contradictions between the fields. If the load level cannot be determined, the estimated execution time is an invalid value, the network data dependency status cannot be read, or the task is declared as pure local computation, but its input data source points to remote data from the edge computing network, then it is determined that there are incomplete features.

[0060] Feature integrity is represented as: ;in, Indicates the first The completeness of the characteristics of a short-term emergency task; This indicates the validity of the load level assessment. It is true when the load level can be determined and belongs to one of the light, medium, or heavy load levels. This indicates the validity of the estimated execution time. It is true when the estimated execution time can be determined and is within a preset reliable time range. This indicates the validity judgment result of the network data dependency state. It is true when the network data dependency state belongs to one of the identifiable states: pure local computing state, network data ready, network data in reservation, network data blocked, or network data unknown. Indicates the first Are there any contradictory fields among the short-term emergency tasks? This indicates a logical AND relationship; This indicates a logical NOT relationship.

[0061] when When true, mark the feature integrity as complete; when... When the value is false, the feature integrity is marked as incomplete. For short-term burst tasks whose feature integrity is marked as incomplete, they are not allowed to enter the first scheduling domain idle window for reuse when generating dual-domain routing resource plans. Instead, they are configured as elastic pool tasks in the second scheduling domain, thus forming a backup routing mechanism in the case of feature missing.

[0062] Even if some scheduling characteristics of short-term burst tasks cannot be accurately identified, it will not affect the deterministic guarantee of periodic hard real-time tasks, and prevent tasks with unknown load, unknown execution duration or unknown network arrival status from entering the real-time dedicated kernel domain idle window.

[0063] S16, after completing the feature integrity verification, the core scheduling layer normalizes the load level, estimated execution time, network data dependency status, and feature integrity fields, so that they are written into the same burst task admission description in a unified field format; the burst task admission description is the direct input for the subsequent generation of dual-domain routing resource plans, and it is used to simultaneously characterize the resource occupation risk, time admission conditions, network data arrival status, and feature credibility of short-term burst tasks.

[0064] No. The description of the emergency mission admission criteria for a short-term emergency mission is as follows:

[0065] ;

[0066] in, Indicates the first Description of emergency mission access for a short-term emergency mission; Indicates the first A task identifier for a short-term, emergency mission; Indicates the first The load level of a short-term, sudden task; Indicates the first The estimated execution time of a short-term emergency task; Indicates the first Network data dependency status for a short-term, sudden task; Indicates the first The completeness of the characteristics of a short-term emergency task; Indicates the first The submission time for a short-term, emergency task; Indicates the first The source types of short-term burst tasks include local computing power-side short-term burst task sources and edge computing network remote burst task sources.

[0067] The update representation of the pending task queue is as follows: ;in, This represents the queue of pending tasks after the pending task admission description has been written. This indicates the queue of pending tasks to be scheduled before being written into the pending task admission description; Indicates the first Description of emergency mission access for a short-term emergency mission; This indicates the set update relationship for adding the emergency task admission description to the queue of emergency tasks to be scheduled.

[0068] When writing to the queue of pending burst tasks, set the queue index according to the submission time, source type, network data dependency status, and load level, so that the burst task admission description in the queue can be read quickly later.

[0069] S2. Based on the sudden task admission description, the current idle window of the real-time dedicated core domain, the dynamic security time boundary, and the available resource status of the elastic pool dedicated core domain, generate a dual-domain routing resource plan.

[0070] S21, the core scheduling layer reads one or more emergency task admission descriptions from the queue of emergency tasks to be scheduled. After parsing the sudden task admission description, the core scheduling layer extracts the key fields used for dual-domain routing judgment to form the dual-domain routing judgment input; the dual-domain routing judgment input is represented as:

[0071] ;

[0072] in, Indicates the first Two-domain routing decision input for a short-term, sudden task; , , and These represent the load level, estimated execution time, network data dependency status, and feature completeness, respectively, obtained from the emergency task admission description.

[0073] A real-time dedicated core domain refers to a dedicated operating area reserved and isolated within a physical processor for periodic hard real-time tasks. Its core function is to ensure that periodic hard real-time services such as robot control, power edge control, and real-time data acquisition from industrial gateways can start and execute stably according to a fixed cycle. It is typically bound to a dedicated CPU core, dedicated memory for the real-time domain, fixed network time slots, and a dedicated cache partition. Hardware mechanisms such as cache partitioning, MMU address isolation, and interrupt affinity are used to block cache contention, memory bandwidth contention, and non-real-time interrupt interference caused by general system tasks or sudden tasks. In this invention, the real-time dedicated core domain corresponds to the first... In principle, the scheduling domain prioritizes the execution of periodic hard real-time tasks. Only when a periodic hard real-time task completes and forms a current idle window, and a short-term burst task meets the following conditions: lightweight load, estimated execution time not exceeding the reusable window after deducting the dynamic safety time boundary, timely network data availability, and complete characteristics, is the short-term burst task allowed to be reused as a task in the first scheduling domain's idle window and run briefly in the idle window of the real-time dedicated kernel domain. Once the dynamic safety time boundary is reached, the two-level schedulers immediately block the burst task from continuing to dequeue and perform forced reclamation to ensure that the next periodic hard real-time task is not delayed.

[0074] S22, the real-time dedicated kernel domain runs periodic hard real-time tasks according to a cycle; the core scheduling layer reads the actual completion time of the current periodic hard real-time task and the trigger time of the next periodic hard real-time task, and determines the current idle window formed by the real-time dedicated kernel domain between two periodic hard real-time tasks accordingly; the current idle window is represented as:

[0075] ;

[0076] in, Indicates the current free window of the real-time dedicated kernel domain; Indicates the trigger time of the next cycle's hard real-time task; This indicates the completion time of the current cycle's hard real-time task.

[0077] Since the task reusing the idle window in the first scheduling domain must release resources before the hard real-time task is triggered in the next cycle, a dynamic safety time boundary needs to be deducted from the current idle window; therefore, the reusable window in the first scheduling domain is represented as:

[0078] ;

[0079] in, Indicates the reusable window of the first scheduling domain; Indicates the currently idle window; The dynamic safety time boundary is used to reserve a safety time margin for context switching, forced resource reclamation, memory binding release, network micro-slot release, and scheduler state recovery. First, multiple rounds of cycle hard real-time task and burst task switching tests are performed in the real-time dedicated kernel domain. The time consumed by context switching, burst task stopping, CPU time slice release, large page memory binding release, network micro-slot release, and scheduler recovery of the hard real-time task queue are recorded. A conservative initial value is set based on the time consumed as the dynamic safety time boundary.

[0080] The latest completion time of the task reused in the first scheduling domain's idle window can be expressed as:

[0081] ;

[0082] in, Indicates the latest end time of the task reused in the first scheduling domain's idle window; Indicates the trigger time of the next cycle's hard real-time task; This indicates the dynamic safety time boundary.

[0083] When the expected end time of the task to be reused in the first scheduling domain's free window is not later than the latest end time, the task is allowed to enter the first scheduling domain; otherwise, even if the short-term burst task is a lightweight task, it is not allowed to reuse the current free window of the real-time dedicated kernel domain.

[0084] S23, the core scheduling layer determines the input based on dual-domain routing. The load level, estimated execution time, network data dependency status, and feature integrity are combined with the reusable window of the first scheduling domain. Joint judgment is made; the first scheduling domain is not open to all emergencies, but only allows short-term emergencies that are short, controllable, have readily available network data and reliable characteristics to enter.

[0085] The first admission result is expressed as:

[0086] ;

[0087] in, Indicates the first The first admission result for a short-term emergency mission; when When, it indicates that the short-term emergency task meets the admission conditions of the first scheduling domain; when When this occurs, it indicates that the short-term emergency task does not meet the admission criteria of the first scheduling domain; Indicates the load level; Indicates the estimated execution time; Indicates the reusable window of the first scheduling domain; Indicates the network data dependency state; This represents the set of network data dependency states that are allowed to enter the first scheduling domain; Indicates feature completeness.

[0088] The set of network data dependency states allowed to enter the first scheduling domain is represented as follows:

[0089] ;

[0090] Among them, the pure local computing state means that the short burst task can be executed without relying on network data; the network data ready state means that the corresponding input data has been received; the network data is being reserved and can be received within the corresponding network micro-slot means that although the network data required by the short burst task has not yet been received, its corresponding network micro-slot has been reserved and is expected to be received before the start of the allocated CPU idle time slice.

[0091] It is known that short-term burst tasks that simultaneously meet four conditions—lightweight load, time falling within the first reusable scheduling window, network data readiness, and complete features—are required to generate a first admission result. If any condition is not met, no first admission result is generated, thereby preventing unknown risk tasks from entering the real-time dedicated kernel domain.

[0092] S24, when the When the first admission result of a short-term burst task indicates that it can enter the first scheduling domain, the core scheduling layer allocates a CPU idle time slice for it in the current idle window of the real-time dedicated core domain, and matches it with the corresponding network micro-time slot, temporary large page memory slice and cache partition usage boundary; the CPU idle time slice must be located before the dynamic safety time boundary between the completion of the current cycle hard real-time task and the triggering of the next cycle hard real-time task.

[0093] The CPU idle time slice in the first scheduling domain is represented as follows:

[0094] ;

[0095] in, Indicates the first A short-duration burst task in the CPU idle time slice of the first scheduling domain; This indicates the start time of the CPU idle time slice. First, the completion time of the current cycle hard real-time task is read as the starting point of the real-time dedicated kernel domain idle window. If no other first scheduling domain idle window reuse task has been scheduled in the idle window, the earliest schedulable time after the completion of the current cycle hard real-time task can be used as the candidate start time of the CPU idle time slice. If other burst tasks have been scheduled in the idle window, the earliest time after the completion time of the previous burst task and its resource release completion time can be used as the candidate start time of the CPU idle time slice. This indicates the end time of the CPU idle time slice. After determining the start time, the start time is added to the estimated execution duration to obtain the candidate end time. Then, the candidate end time is compared with the latest allowed end time obtained by subtracting the dynamic safety time boundary from the trigger time of the next hard real-time task. If the candidate end time is not later than the latest allowed end time, the candidate end time is determined as the end time of the CPU idle time slice.

[0096] The CPU idle time slice must meet the following requirements:

[0097] ;

[0098] ;

[0099] in, Indicates the completion time of the current cycle's hard real-time task; Indicates the start time of execution of the task reused in the first scheduling domain's idle window; Indicates the end time of the execution of the task reused in the first scheduling domain's idle window; Indicates the trigger time of the next cycle's hard real-time task; Indicates the dynamic safety time boundary; This indicates the estimated execution time.

[0100] When this short-duration burst task has network data dependencies, it must also satisfy the spatiotemporal matching constraints of the computing network; the network micro-slot is represented as:

[0101] ;

[0102] in, Indicates the first A short-duration, bursty task corresponds to the network micro-slot in the first scheduling domain; It indicates the start time of the network micro-slot, which is calculated by working backward from the data source of the burst task, the start time of the CPU idle time slice, and the network transmission preparation margin. The end time of the network micro-slot is indicated by adding the data transmission duration, switching and forwarding duration, DMA receive and write duration, and transmit / receive protection margin to the start time after determining the start time of the network micro-slot. If the candidate end time is earlier than or equal to the start time of the CPU idle time slice, then the candidate end time is determined as the end time of the network micro-slot.

[0103] The corresponding spatiotemporal matching relationship of the computing network is represented as follows:

[0104] ;

[0105] in, Indicates the end time of a network micro-slot; This indicates the start time of the CPU idle time slice; it also indicates that network data should be received before the CPU idle time slice begins, thus preventing the CPU time slice from idling due to unread data.

[0106] The core scheduling layer writes the task identifier, first scheduling domain identifier, CPU idle time slice, network micro-slot, temporary large page memory slice, and cache partition usage boundary of the short-term burst task into the dual-domain routing resource plan, so that the short-term burst task is configured as a first scheduling domain idle window reuse task.

[0107] The plan item for reusing tasks within the first scheduling domain's idle window is represented as follows:

[0108] ;

[0109] in, Indicates the first The first scheduling domain plan item corresponding to a short-term emergency task; Indicates the task identifier; Indicates the identifier of the first scheduling domain; Indicates CPU idle time slice; Indicates a network micro-timeslot; This indicates a temporary large page memory fragment; Indicates the boundary of cache partition usage; This indicates the resource reclamation trigger condition for the first scheduling domain, which is the dynamic safety time boundary before the next cycle hard real-time task triggering time.

[0110] S25, if the first If a short-term burst task does not meet the admission conditions of the first scheduling domain, the core scheduling layer generates a second admission result. The second admission result is not an abnormal result, but a backup routing result for medium-volume tasks, heavy-duty tasks, tasks with long execution time, tasks for which network data cannot be ready in time, and tasks with incomplete features. It can prevent uncertain tasks from entering the real-time dedicated core domain, while ensuring that burst tasks can still obtain continuous running resources in the elastic pool dedicated core domain.

[0111] The dedicated core domain of the elastic pool refers to an area specifically designed to handle bursty tasks. Its core function is to provide continuous, isolated, and reusable computing network resources for tasks unsuitable for entering the idle window of the real-time dedicated core domain. It consists of dedicated CPU cores, CPU time slices, large page memory slices, network micro-slots, and cache partitions. Instead of using the traditional long-term static reservation method for entire cores, it finely divides resources and allocates them to tasks in the elastic pool of the second scheduling domain as needed. In this invention, the dedicated core domain of the elastic pool corresponds to the second scheduling domain and is used to receive medium-volume tasks, heavy-duty tasks, and tasks whose estimated execution time exceeds that of the first scheduling domain. Tasks that reuse windows, tasks whose network data is not ready in a timely manner, and tasks with incomplete features, as well as any sudden tasks that do not meet the admission conditions of the first scheduling domain, are configured as elastic pool tasks in the second scheduling domain through the dual-domain routing resource plan. They continuously occupy one or more CPU time slices, large page memory slices, and network micro-time slots in the dedicated core domain of the elastic pool until the task is completed or an independent exception is triggered. If network data is not ready, the task is marked as a network blocking task and placed in the delayed retry queue. At the same time, the CPU time slices that have not yet been used are transferred to other ready tasks, thereby avoiding idle computing power.

[0112] The second admission result is expressed as follows:

[0113] ;

[0114] in, Indicates the first The second admission result for a short-term emergency mission; Indicates the first The first admission result for a short-term emergency mission; when When, it indicates that the short-term burst task is configured as a task in the second scheduling domain elastic pool; when When this occurs, it indicates that the short-term burst task has been configured as a reuse task within the first scheduling domain's idle window.

[0115] The available resource status of the dedicated kernel domain in the elastic pool is represented as follows:

[0116] ;

[0117] in, Indicates the available resource status of the dedicated kernel domain of the elastic pool; This represents the set of available CPU time slices within the dedicated kernel domain of the elastic pool; This represents the set of available large page memory slices; This represents the set of available network micro-slots; This represents the set of available cache partitions.

[0118] After the second admission result is generated, the core scheduling layer matches one or more sets of CPU time slices, large page memory slices, network micro-slots and cache partitions for the corresponding short-term burst tasks based on the available resource status of the elastic pool dedicated core domain. For short-term burst tasks with network data dependency status of network data blocking or unknown network data, a delayed schedulable flag can be set for them in the dual-domain routing resource plan, so that they can enter the ready execution sequence of the elastic pool dedicated core domain after the network data is ready or the retry conditions are completed.

[0119] S26, the second scheduling domain elastic pool task runs in the elastic pool dedicated core domain. It does not occupy the idle window of the real-time dedicated core domain, nor is it forcibly interrupted when the first scheduling domain reaches the dynamic safety time boundary. For medium-volume or heavy-volume burst tasks, the core scheduling layer allocates multiple CPU time slices that are continuous or non-contiguous but logically connectable, and matches them with corresponding large page memory slices, network micro-time slots and cache partitions, so that they can run continuously in the elastic pool dedicated core domain until completion.

[0120] The set of CPU time slices in the second scheduling domain is represented as follows:

[0121] ;

[0122] in, Indicates the first A set of CPU time slices obtained by a short-duration burst task in the second scheduling domain; Indicates the first The first short-term emergency mission obtained One CPU time slice; This indicates the number of CPU time slices obtained by the short burst task.

[0123] The CPU time slice set satisfies:

[0124] ;

[0125] in, Indicates the first The duration of a CPU time slice; Indicates the first The estimated execution time of a short-term burst task is indicated by the fact that the total CPU time slice allocated to the task in the second scheduling domain elastic pool is not less than its estimated execution time.

[0126] The plan item for the elastic pool task in the second scheduling domain is represented as follows:

[0127] ;

[0128] in, Indicates the first The second scheduling domain plan item corresponding to a short-term emergency task; Indicates the task identifier; Indicates the identifier of the second scheduling domain; Represents the set of CPU time slices; Represents a set of network micro-time slots; Represents a set of large page memory slices; Indicates a cache partition; This indicates the resource reclamation trigger condition for the second scheduling domain, which includes task completion and independent exception handling. This indicates the network scheduling status, which includes network ready, network blocked, and delayed retry.

[0129] Medium-duration tasks, heavy-duty tasks, long-duration tasks, tasks with uncertain network data, and tasks with incomplete features can all be included in the second scheduling domain elastic pool tasks, and the elastic pool's dedicated core domain provides continuous running capability, thereby avoiding resource idleness caused by traditional static full core reservation.

[0130] S27, the core scheduling layer will uniformly arrange the first scheduling domain plan items and the second scheduling domain plan items to form a dual-domain routing resource plan; the dual-domain routing resource plan not only records whether the task is assigned to the first scheduling domain or the second scheduling domain, but also records the computing power, memory, network and cache resources that the task can use in the corresponding scheduling domain, as well as the subsequent resource reclamation trigger conditions.

[0131] For the For a short-term, emergency task, the final plan item is represented as follows:

[0132] ;

[0133] in, Indicates the first The final planned item of a short-term burst task in the dual-domain routing resource plan; Indicates the first scheduling domain plan item; Indicates the second scheduling domain plan item; This indicates the first admission result; This indicates the second admission result.

[0134] A dual-domain routing resource plan is represented as:

[0135] ;

[0136] in, Indicates a dual-domain routing resource plan; These represent the final plan items for each short-term burst task written into the dual-domain routing resource plan; This indicates the number of short-term burst tasks involved in generating the dual-domain routing resource plan in this round.

[0137] Each final plan item is bound to the following field:

[0138] ;

[0139] in, Indicates the task identifier; This indicates a task domain identifier, which is used to distinguish between the first scheduling domain and the second scheduling domain. Indicates the start time of execution; This indicates a CPU time slice or a CPU idle time slice. Indicates a network micro-timeslot; This indicates a large page memory fragment; Indicates a cache partition; This indicates the conditions that trigger resource recycling.

[0140] Specifically, for the idle window reuse task in the first scheduling domain, the resource reclamation trigger condition is the dynamic safety time boundary before the trigger time of the next hard real-time task in the next cycle, or the task is completed ahead of schedule; for the elastic pool task in the second scheduling domain, the resource reclamation trigger condition is the completion of the task or the end of independent exception handling.

[0141] The admission description of the sudden tasks in the queue of pending sudden tasks is parsed into dual-domain routing judgment input. Then, combined with the current idle window of the real-time dedicated core domain, the dynamic security time boundary, and the available resource status of the elastic pool dedicated core domain, an executable dual-domain routing resource plan is formed. The dual-domain routing resource plan configures short-term sudden tasks that meet the security reuse conditions as idle window reuse tasks in the first scheduling domain, and configures other sudden tasks as elastic pool tasks in the second scheduling domain. This improves the elastic carrying capacity of the computing network scheduling system for sudden tasks while ensuring the determinism of periodic hard real-time tasks.

[0142] S3. Perform burst task scheduling according to the dual-domain routing resource plan. In the first scheduling domain, the two-level scheduler driven by the hardware timer runs the first scheduling domain idle window reuse task only during the idle window of the periodic hard real-time task, and performs forced reclamation when the dynamic safety time boundary is reached. In the second scheduling domain, the elastic pool tasks of the second scheduling domain are allocated to the elastic resource pool composed of CPU time slices, large page memory slices, network micro time slots and cache partitions for continuous operation, and the elastic resource pool scheduling result is generated according to the task end status, network blocking status and resource reclamation status.

[0143] S31, Read the dual-domain routing resource plan The first scheduling domain plan item for the idle window reuse task in the first scheduling domain and the second scheduling domain plan item for the elastic pool task in the second scheduling domain are obtained by parsing.

[0144] For the parsed first scheduling domain plan item, the core scheduling layer writes the corresponding first scheduling domain idle window reuse task into the burst task queue of the two-level scheduler; the two-level scheduler is deployed in the real-time dedicated core domain and runs independently of the general operation scheduler in the general core domain; the two-level scheduler maintains at least a periodic hard real-time task queue and a burst task queue, wherein the periodic hard real-time task queue is used to carry periodic hard real-time tasks, and the burst task queue is used to carry the first scheduling domain idle window reuse task.

[0145] The periodic hard real-time task queue is represented as:

[0146] ;

[0147] in, This represents a periodic hard real-time task queue; These represent the periodic hard real-time tasks in the periodic hard real-time task queue, respectively. This indicates the number of periodic hard real-time tasks.

[0148] The emergency task queue is represented as follows: ;in, Indicates a queue of urgent tasks; These represent the first scheduling domain idle window reuse task written into the burst task queue; This indicates the number of tasks that can be reused in the idle window of the first scheduling domain.

[0149] The two-level scheduler is triggered by a high-precision hardware timer, and performs queue arbitration each time a hardware timer interrupt occurs; the queue arbitration result is expressed as follows:

[0150] ;

[0151] in, Indicates time The results of the queue arbitration; This represents a periodic hard real-time task queue; Indicates a queue of urgent tasks; Indicates an empty queue; This indicates the current time corresponding to the current hardware clock. Indicates the first The first scheduling domain's idle window reuses the CPU idle time slice of the task.

[0152] When there are ready tasks in the periodic hard real-time task queue, the two-level scheduler prioritizes restoring and running the periodic hard real-time tasks without invoking the normal scheduling process of the general kernel domain. When the periodic hard real-time task queue is empty and the current time is within the CPU idle time slice, the two-level scheduler allows the first scheduling domain idle window multiplexed task in the burst task queue to be dequeued and run. The first scheduling domain idle window multiplexed task can only run within the idle window of the periodic hard real-time task and does not have the ability to preempt the periodic hard real-time task.

[0153] S32, when the queue arbitration result When reusing a task within the first scheduling domain's idle window, before running the task, its temporary large page memory slice, network micro-slot, and cache partition usage boundary are bound according to the first scheduling domain's plan item, and the data readiness status corresponding to the network micro-slot is verified. The temporary large page memory slice is used to provide the task with memory space that can be quickly unmapped. The network micro-slot is used to ensure that the network data required by the task is received before the start of the CPU idle time slice. The cache partition usage boundary is used to limit the cache access range of the task to avoid it violating the cache isolation requirements of the real-time dedicated kernel domain for periodic hard real-time tasks.

[0154] The resource binding relationship of the task reused in the first scheduling domain's idle window is represented as follows: ;in, Indicates the first Resource binding relationships for reusing tasks within the first scheduling domain's idle window; Indicates the first The first scheduling domain's idle window reuses the task; This indicates a temporary large page memory fragment; Indicates a network micro-timeslot; This indicates the boundary of the cache partition.

[0155] After resource binding is completed, the core scheduling layer verifies the data readiness status corresponding to the network micro-slot; the network data readiness determination result is expressed as:

[0156] ;

[0157] in, Indicates the first The network data readiness determination result for the first scheduling domain idle window reuse task; This indicates the network data dependency state.

[0158] when When, it indicates that the task can be executed in the first scheduling domain; when When this occurs, it indicates that the task cannot be executed in the first scheduling domain.

[0159] When network data is ready or the corresponding task is a purely local computing task, the idle window multiplexing task in the first scheduling domain is executed; when network data is not ready in the corresponding network micro-slot, the task is blocked from dequeuing in the first scheduling domain and marked as a network blocked state.

[0160] S33, During the execution of the first scheduling domain's idle window reuse task, the two-level scheduler continuously reads the current hardware clock and compares it with the dynamic safety time boundary before the trigger time of the next cycle's hard real-time task. If the task is triggered to complete early or is forcibly reclaimed, the scheduler determines the appropriate time based on the resource binding relationship. The binding relationship between the first scheduling domain's idle window reuse task and the temporary large page memory shard, network micro-slot, and cache partition usage boundary is released; the dynamic safety time boundary is not the task end time, but a forced reclamation trigger line, used to ensure that all CPU, memory, network, and cache resources occupied by sudden tasks have been released before the next cycle of hard real-time task triggering.

[0161] The forced reclamation trigger time is represented as follows: ;in, Indicates the time when forced reclamation is triggered; Indicates the trigger time of the next cycle's hard real-time task; This indicates the dynamic safety time boundary.

[0162] The result of the forced reclamation judgment is expressed as follows:

[0163] ;

[0164] in, Indicates the first The first scheduling domain idle window reuse task at time The results of the recycling judgment; This indicates the current time corresponding to the current hardware clock. Indicates the time when forced reclamation is triggered; Indicates the first The first scheduling domain's idle window reuses the task.

[0165] when When, it means that recycling will not be triggered for the time being; when When this occurs, it indicates that resource release or forced reclamation is triggered.

[0166] When the task in the first scheduling domain's idle window is completed ahead of schedule, the core scheduling layer releases the CPU idle time slice, temporary large page memory slice, network micro-slot, and cache partition usage boundary it occupied; the release status is indicated as: ;in, Indicates the first The resource release status of the first scheduling domain's idle window reuse task; Indicates the CPU idle time slice release status; Indicates the temporary large page memory fragment release status; Indicates the network micro-slot release status; This indicates that the cache partition is in the bounds release state.

[0167] When the current hardware clock reaches the forced reclamation trigger time, the two-level scheduler blocks the dequeue path of the burst task queue, preventing new first-schedule domain free window reused tasks from entering the running state. At the same time, it performs forced reclamation on the first-schedule domain free window reused tasks that are still running in the first-schedule domain, removing their context running state, memory mapping relationship, network micro-time slot occupancy relationship, and cache partition usage boundary, thereby ensuring that the hard real-time tasks in the next cycle can obtain a deterministic execution environment of the real-time dedicated kernel domain at the trigger time.

[0168] S34, for the parsed second scheduling domain plan item, the core scheduling layer allocates the corresponding second scheduling domain elastic pool task to the elastic pool dedicated core domain; the elastic pool dedicated core domain and the real-time dedicated core domain are kept isolated through hardware cache partitioning, memory address space isolation and interrupt affinity configuration, so that the second scheduling domain elastic pool task will not preempt the periodic hard real-time task in the real-time dedicated core domain when running continuously in the elastic pool dedicated core domain.

[0169] The elastic resource pool consists of CPU time slices, large page memory slices, network micro-slots, and cache partitions, represented as follows: ;in, Indicates an elastic resource pool; This represents the set of CPU time slices within the dedicated kernel domain of the elastic pool; Represents a set of large page memory slices; Represents a set of network micro-time slots; This represents a set of cache partitions.

[0170] Based on the elastic resource pool From CPU time slice set Large page memory fragment set Network micro-timeslot collection and cache partition set In this process, a corresponding set of CPU time slices is selected for the tasks in the second scheduling domain's elastic pool. Large page memory fragment set Network micro-timeslot collection and cache partition .

[0171] For the The resource allocation relationship for each second scheduling domain elastic pool task is represented as follows:

[0172] ;

[0173] in, Indicates the first Resource allocation relationships for tasks in the second scheduling domain elastic pool; Indicates the first A second scheduling domain elastic pool task; This represents the set of CPU time slices allocated to this task; This represents the set of large page memory slices allocated to this task; This represents the set of network micro-slots assigned to this task; This indicates the cache partition allocated to this task.

[0174] The second scheduling domain elastic pool task can continuously occupy one or more CPU time slices, large page memory slices and network micro time slots according to the second scheduling domain plan, and run continuously in the elastic pool dedicated core domain until the task is completed or an independent exception is triggered. Unlike the first scheduling domain, the second scheduling domain elastic pool task is not forcibly interrupted when the first scheduling domain reaches the dynamic safety time boundary. Its reclamation is triggered by the task completion status or the independent exception handling status.

[0175] S35, in the second scheduling domain, the core scheduling layer continuously monitors whether network data is ready within the expected network micro-slot based on the network data dependency status of the elastic pool tasks in the second scheduling domain; when an elastic pool task in the second scheduling domain is marked as a network blocking task, it is based on its resource allocation relationship. The system determines the CPU time slice that has been allocated but not yet used for the task, and writes the CPU time slice back to the set of available CPU time slices in the elastic resource pool for reuse by other second scheduling domain elastic pool tasks that have network data ready or are purely local computations. If the task is a purely local computation task, it does not need to wait for network data and can be executed directly according to the allocated CPU time slice. If the task depends on network data, the system reads the network micro-slot status, the network card DMA receive status register, or the data ready flag in memory before the start of the corresponding CPU time slice to determine whether the task meets the execution conditions.

[0176] The network congestion determination result is expressed as follows:

[0177] ;

[0178] in, Indicates the first Network congestion assessment results for the second scheduling domain elastic pool task; This indicates the network data dependency state.

[0179] when When there is no network congestion, execution can proceed; when When this occurs, it indicates that network congestion exists.

[0180] when At this time, the core scheduling layer marks the second scheduling domain elastic pool task as a network blocking task and puts it into the delayed retry queue; the delayed retry queue is represented as follows: ;in, This represents the updated delayed retry queue; This represents the delayed retry queue before the update. This refers to the second scheduling domain elastic pool task that is marked as a network blocking task.

[0181] When network data is restored and ready, retrieve it from the updated delayed retry queue. The corresponding network blocking task is read and removed from the kernel, and then rewritten into the ready execution sequence of the elastic pool dedicated kernel domain.

[0182] The CPU time slices allocated to but not yet used for the network-blocking task are transferred to the second scheduling domain's elastic pool tasks where other network data is ready or purely local computation is performed; the set of transferred CPU time slices is represented as: ;in, This represents the set of CPU time slices that can be handed over; Represents a CPU time slice; Indicates the original allocation to the first The set of CPU time slices for tasks in the second scheduling domain elastic pool.

[0183] The set of CPU time slices that can be transferred Write back to the set of available CPU time slices in the elastic resource pool, and from the set of CPU time slices that can be handed over. The second scheduling domain elastic pool tasks, which are either ready for other network data or purely local computation, reallocate CPU time slices.

[0184] When network data is restored and ready, the core scheduling layer rewrites the network blocking task from the delayed retry queue into the ready execution sequence of the elastic pool dedicated kernel domain; the updated ready execution sequence is represented as follows:

[0185] ;

[0186] in, This indicates the updated ready execution sequence; This indicates the ready execution sequence before the update; This refers to the second scheduling domain elastic pool task after network data recovery is ready.

[0187] The dedicated kernel domain for the elastic pool is based on the updated ready execution sequence. They will re-participate in the CPU time slice allocation for tasks in the second scheduling domain elastic pool.

[0188] It can prevent the CPU time slice of the dedicated core domain of the elastic pool from idling when network data is not ready, so that the elastic pool tasks in the second scheduling domain can still maintain a high resource utilization rate in network congestion scenarios.

[0189] S36, after the execution of the first and second scheduling domains is completed, the core scheduling layer summarizes the task completion status, network blocking status, and resource reclamation status of each short-term burst task, and generates the elastic resource pool scheduling result; the task completion status is used to characterize whether the task reused in the idle window of the first scheduling domain or the elastic pool task of the second scheduling domain is completed normally, forcibly reclaimed, or triggered independent exception handling; the network blocking status is used to characterize whether the corresponding task enters the delayed retry queue due to network data not being ready; the resource reclamation status is used to characterize whether the CPU time slice, large page memory slice, network micro-time slot, and cache partition have been released and can be reused by subsequent burst tasks.

[0190] When the corresponding task is a multiplexed task within the first scheduling domain's free window, the obtained resource release status will be... The resource reclamation status of the task is used as the resource reclamation status. When the corresponding task is a second scheduling domain elastic pool task, the release status of CPU time slices, large page memory slices, network micro-slots and cache partitions in the second scheduling domain is used as the resource reclamation status of the task.

[0191] No. The completion status of a short-term, contingent task is represented as follows:

[0192] ;

[0193] in, Indicates the first The mission completion status of a short-term emergency task; Indicates the first A short-term, emergency task.

[0194] No. The network congestion state of a short-duration burst task is represented as follows:

[0195] ;

[0196] in, Indicates the first A network congestion state for a short-term, sudden task; This indicates the network congestion assessment result.

[0197] When the corresponding task is a task in the second scheduling domain elastic pool, it is based on its resource allocation relationship. The release status of CPU time slices, large page memory slices, network micro-slots, and cache partitions is determined, and the resource release status of the second scheduling domain elastic pool tasks is represented as follows:

[0198] ;

[0199] in, Indicates the first Resource release status of each second scheduling domain elastic pool task; Indicates the first The CPU time slice release status of a second scheduling domain elastic pool task; Indicates the first The status of large page memory fragments occupied by tasks in the second scheduling domain's elastic pool has been released. Indicates the first Release status of network micro-slots occupied by tasks in the second scheduling domain elastic pool; Indicates the first Release status of cache partitions occupied by tasks in the second scheduling domain elastic pool.

[0200] No. The resource recovery status of a short-term emergency task is represented as follows:

[0201] ;

[0202] in, Indicates the first Resource recovery status for a short-term emergency task; Indicates whether the CPU time slice or CPU idle time slice has been released; Indicates whether a large page memory fragment or a temporary large page memory fragment has been released; Indicates whether a network micro-slot has been released; This indicates whether the cache partition or cache partition usage boundary has been released.

[0203] The scheduling result of the elastic resource pool is represented as follows:

[0204] ;

[0205] in, This indicates the scheduling result of the elastic resource pool; Indicates the task identifier; Indicates the task is complete; Indicates a network congestion state; Indicates the status of resource recycling; This indicates the number of tasks involved in this round of emergency task scheduling.

[0206] The resource release status in the first scheduling domain that is completed ahead of schedule or reaches the dynamic safety time boundary, the resource reclamation status in the second scheduling domain after task completion or abnormal handling, and the status of network-blocked tasks entering the delayed retry queue are all uniformly recorded in the elastic resource pool scheduling results.

[0207] The first scheduling domain strictly restricts bursty tasks to run only within the idle window of periodic hard real-time tasks through a two-level scheduler driven by hardware timers, and triggers forced reclamation at dynamic safety time boundaries; the second scheduling domain supports continuously running tasks through an elastic resource pool consisting of CPU time slices, large page memory slices, network micro-time slots, and cache partitions, and forms a closed loop through network blocking delay retry and resource reclamation status recording; this ensures both the determinism of periodic hard real-time tasks and improves the elastic carrying capacity of bursty tasks in the computing network scheduling system.

[0208] Example 2

[0209] like Figure 4 As shown, a bursty task elastic resource pool scheduling system for computing network scheduling systems includes the following modules:

[0210] The admission normalization identification module is used to perform admission normalization identification on sudden tasks entering the core scheduling layer, and synthesize the load level, estimated execution time, network data dependency status and feature integrity into a sudden task admission description, and write the sudden task admission description into the queue of sudden tasks to be scheduled.

[0211] The dual-domain routing decision module is used to generate a dual-domain routing resource plan based on the burst task admission description, the current idle window of the real-time dedicated core domain, the dynamic security time boundary, and the available resource status of the elastic pool dedicated core domain. The burst tasks that meet the admission conditions of the first scheduling domain are configured as the idle window reuse tasks of the first scheduling domain, and the burst tasks that do not meet the admission conditions of the first scheduling domain or have incomplete characteristics are configured as elastic pool tasks of the second scheduling domain.

[0212] The scheduling execution management module is used to run the idle window reuse task of the first scheduling domain in the first scheduling domain through a two-level scheduler driven by a hardware timer in accordance with the dual-domain routing resource plan, and to perform forced reclamation when the dynamic safety time boundary is reached; it is also used to allocate the elastic pool tasks of the second scheduling domain to the elastic resource pool composed of CPU time slices, large page memory slices, network micro time slots and cache partitions for continuous operation in the second scheduling domain, and to generate the elastic resource pool scheduling result based on the task completion status, network blocking status and resource reclamation status.

[0213] This invention encompasses any substitutions, modifications, equivalent methods, and solutions made within the spirit and scope of this invention. To provide the public with a thorough understanding of this invention, specific details are described in detail in the following preferred embodiments; however, those skilled in the art will fully understand the invention even without these details. Furthermore, to avoid unnecessary misunderstanding of the essence of this invention, well-known methods, processes, procedures, components, and circuits are not described in detail.

[0214] The above description is only a preferred embodiment of the present invention. It should be noted that for those skilled in the art, several improvements and modifications can be made without departing from the principle of the present invention, and these improvements and modifications should also be considered within the scope of protection of the present invention.

Claims

1. A method for scheduling bursty tasks using an elastic resource pool in a computing network scheduling system, characterized in that, Includes the following steps: Based on the sudden tasks entering the core scheduling layer, admission normalization identification is performed. The load level, estimated execution time, network data dependency status and feature integrity are combined into a sudden task admission description and written into the queue of sudden tasks to be scheduled. Based on the sudden task admission description, the current idle window of the real-time dedicated core domain, the dynamic security time boundary, and the available resource status of the elastic pool dedicated core domain, obtain the dual-domain routing resource plan; Based on the dual-domain routing resource plan, in the first scheduling domain, a two-level scheduler driven by a hardware timer runs the first scheduling domain idle window reuse task in the periodic hard real-time task idle window, and forcibly reclaims it when the dynamic safety time boundary is reached. In the second scheduling domain, elastic pool tasks are run based on the elastic resource pool consisting of CPU time slices, large page memory slices, network micro-time slots, and cache partitions, and the scheduling results of the elastic resource pool are obtained.

2. The method for scheduling bursty tasks using an elastic resource pool in a computing network scheduling system according to claim 1, characterized in that, Tasks entering the core scheduling layer are identified by their task attributes. Based on the task's execution cycle, triggering method, and resident status, it is determined whether the task is a short-term burst task. If the identification result is a periodic hard real-time task, it is handed over to the hard real-time task queue of the real-time dedicated core domain for processing. If the identification result is a short-term burst task, then a burst task identification result is generated; Based on the identified burst task results, the CPU, memory, and network bandwidth requirements of short-term burst tasks are classified and identified to obtain CPU load sub-levels, memory load sub-levels, and network load sub-levels. When multiple load sub-levels are inconsistent, a conservative expansion and classification method is adopted, and the highest load sub-level is determined as the load level of the short-term burst task, expressed as: ； in, Indicates the first The load level of a short-term, sudden task; This indicates that the highest level is selected according to the order of rank; Indicates the CPU load sub-level; Indicates the memory load sublevel; Indicates network load sub-level; Based on the identified sudden task results, the task type, historical execution records under standard operating conditions, the longest execution time declared by the task submitter, and the completion time of similar tasks are read to determine the estimated execution time of the short-term sudden task, expressed as follows: ； in, Indicates the first The estimated execution time of a short-term emergency task; This indicates taking the maximum value; Indicates the first A short-duration, contingent task is defined by the maximum runtime declared by the task submitter. Indicates the first Reference completion time corresponding to the historical execution record of a short-term emergency task under standard operating conditions; Indicates the relationship with the first The completion time reference value for a short-term emergency task is similar to that of other tasks. This represents the safety compensation amount for execution duration. When there is a discrepancy between the historical execution record and the longest running time declared by the task submission end, the result that is not less than the larger of the two times is selected as the estimated execution duration, so that the estimated execution duration can be used to subsequently determine whether the short-term burst task can fall into the current idle window after deducting the dynamic safety time boundary.

3. The method for scheduling bursty tasks using an elastic resource pool in a computing network scheduling system according to claim 2, characterized in that, Based on the results of the sudden task identification, it is determined whether the short-term sudden task depends on remote data from the edge computing network, TSN network micro-slot received data, or local network card DMA received data; if there is network data dependency, the corresponding network micro-slot reservation status, network card DMA receive status register, or data ready flag in memory is read to obtain the network data dependency status. If there is no network data dependency, then the short-term burst task is marked as a pure local computation burst task, and the pure local computation state is written into the network data dependency state as follows: ;in, Indicates the first Network data dependency status for a short-term, sudden task; This represents a function to determine network data dependency states. Indicates the first Does a short-term, emergency task depend on network data? Indicates the first The network micro-slot reservation status corresponding to a short-term emergency task; Indicates the first The DMA receive status register read results corresponding to each short-term burst task; This indicates the result of reading the data ready flag in memory; The integrity check of the load level, estimated execution time, and network data dependency status is represented as follows: ;in, Indicates the first The completeness of the characteristics of a short-term emergency task; This indicates the result of the load level validity assessment; This indicates the result of the validity assessment of the estimated execution time; This indicates the result of the network data dependency state validity judgment; Indicates the first Are there any contradictory fields among the short-term emergency tasks? This indicates a logical AND relationship; The logical NOT relationship is indicated; when the load level, estimated execution time, and network data dependency status can all be effectively determined, the feature integrity is marked as complete; when any of the load level, estimated execution time, or network data dependency status cannot be determined, exceeds the confidence range, or contradicts each other, the feature integrity is marked as incomplete. The load level, estimated execution duration, network data dependency status, and feature integrity are combined into a sudden task admission description according to a unified field format. The sudden task admission description is then bound to the task identifier, submission time, and source type of the corresponding short-term sudden task and written into the sudden task queue to be scheduled.

4. The method for scheduling bursty tasks using an elastic resource pool in a computing network scheduling system according to claim 1, characterized in that, The admission description of the sudden task is read from the queue of sudden tasks to be scheduled, and the load level, estimated execution duration, network data dependency status and feature integrity of the corresponding short-term sudden task are parsed to obtain the parsed result as the input for the dual-domain routing decision: ； in, Indicates the first Two-domain routing decision input for a short-term, sudden task; , , and These represent the load level, estimated execution time, network data dependency status, and feature completeness, respectively, obtained from the emergency task admission description. Read the completion time of the current cycle hard real-time task and the trigger time of the next cycle hard real-time task in the real-time dedicated kernel domain, determine the current idle window of the real-time dedicated kernel domain, and obtain the first scheduling domain reusable window based on the current idle window and the dynamic safety time boundary. The first scheduling domain reusable window is used to limit the latest end time of the task reused in the first scheduling domain idle window, which can be expressed as: ； in, Indicates the latest end time of the task reused in the first scheduling domain's idle window; Indicates the trigger time of the next cycle's hard real-time task; Indicates the dynamic safety time boundary; Based on the dual-domain routing judgment input and the first scheduling domain reusable window, the first scheduling domain admission judgment is performed; when the load level is lightweight, the estimated execution time is not greater than the first scheduling domain reusable window, the network data dependency state indicates that the network data can be ready within the corresponding network micro-slot, and the feature integrity is complete, the first admission result is generated as follows: ； in, Indicates the first The first admission result for a short-term emergency mission; Indicates the load level; Indicates the estimated execution time; Indicates the reusable window of the first scheduling domain; Indicates the network data dependency state; This represents the set of network data dependency states that are allowed to enter the first scheduling domain; Indicates feature completeness.

5. A method for scheduling bursty tasks using an elastic resource pool in a computing network scheduling system according to claim 4, characterized in that, After generating the first admission result, the CPU idle time slice, corresponding network micro-time slot, temporary large page memory slice and cache partition usage boundary in the real-time dedicated core domain are matched for the corresponding short-term burst task, and the matching result is written into the dual-domain routing resource plan, so that the short-term burst task is configured as a first scheduling domain idle window reuse task in the dual-domain routing resource plan. When the load level is not lightweight, the estimated execution duration is greater than the reusable window of the first scheduling domain, the network data dependency status indicates that the network data cannot be ready within the corresponding network micro-slot, or the feature integrity is incomplete, the generated second admission result is expressed as follows: ； in, Indicates the first The second admission result for a short-term emergency mission; Indicates the first The first admission result of a short burst task is used to match the CPU time slice, large page memory slice, network micro-slot and cache partition in the elastic pool dedicated core domain to the corresponding short burst task based on the available resource status of the elastic pool dedicated core domain.

6. A method for scheduling bursty tasks using an elastic resource pool in a computing network scheduling system according to claim 5, characterized in that, The matched elastic pool dedicated core domain resources are written into the dual-domain routing resource plan, so that the corresponding short-term burst task is configured as a second scheduling domain elastic pool task in the dual-domain routing resource plan; wherein, the second scheduling domain elastic pool task can continuously occupy multiple CPU time slices, large page memory slices or network micro time slots until the task is completed or an independent exception is triggered. The first scheduling domain idle window reuse task and the second scheduling domain elastic pool task are respectively bound to the task domain identifier, execution start time, CPU time slice, network micro-time slot, large page memory slice, cache partition, and resource reclamation trigger condition to form the dual-domain routing resource plan as follows: ； in, Indicates a dual-domain routing resource plan; These represent the final plan items for each short-term burst task written into the dual-domain routing resource plan; This indicates the number of short-term burst tasks involved in generating the dual-domain routing resource plan in this round.

7. A method for scheduling bursty tasks using an elastic resource pool in a computing network scheduling system according to claim 1, characterized in that, Read the dual-domain routing resource plan and parse it to obtain the first scheduling domain plan item of the first scheduling domain idle window reuse task and the second scheduling domain elastic pool task. Based on the first scheduling domain plan item, the corresponding first scheduling domain idle window reuse task is written into the burst task queue of the two-level scheduler, and the two-level scheduler is driven by a hardware timer to perform queue arbitration in the real-time dedicated core domain. The result is expressed as follows: ； in, Indicates time The results of the queue arbitration; This represents a periodic hard real-time task queue; Indicates a queue of urgent tasks; Indicates an empty queue; This indicates the current time corresponding to the current hardware clock. Indicates the first The first scheduling domain's idle window reuses the CPU idle time slice of the task; when there are ready tasks in the periodic hard real-time task queue, the two-level scheduler prioritizes restoring and running the periodic hard real-time task; when the periodic hard real-time task queue is empty and the current time is within the CPU idle time slice, the two-level scheduler allows the first scheduling domain's idle window reused task to be dequeued and run. Before running the first scheduling domain idle window reuse task, the temporary large page memory fragment, network micro-slot, and cache partition usage boundary are bound according to the first scheduling domain plan item, and the data readiness status corresponding to the network micro-slot is verified; when the network data is ready or the corresponding task is a pure local computing task, the first scheduling domain idle window reuse task is executed; when the network data is not ready in the corresponding network micro-slot, the task is blocked from dequeuing in the first scheduling domain and marked as network blocked.

8. A method for scheduling bursty tasks using an elastic resource pool in a computing network scheduling system according to claim 7, characterized in that, During the execution of the idle window reuse task in the first scheduling domain, the dynamic safety time boundary before the trigger time of the next cycle hard real-time task is continuously compared with the current hardware clock. When the idle window reuse task in the first scheduling domain completes ahead of schedule, the CPU idle time slice, temporary large page memory slice, network micro-time slot and cache partition usage boundary occupied by it are released. When the current hardware clock reaches the dynamic safety time boundary, the two-level scheduler blocks the dequeue path of the burst task queue and performs forced reclamation on the idle window reuse task in the first scheduling domain that is still running in the first scheduling domain. Based on the second scheduling domain plan item, the corresponding second scheduling domain elastic pool task is allocated to the elastic resource pool in the elastic pool dedicated core domain.

9. A method for scheduling bursty tasks using an elastic resource pool in a computing network scheduling system according to claim 8, characterized in that, During the execution of a task in the second scheduling domain elastic pool, network congestion status is monitored based on its network data dependency status. When the corresponding network data is not ready within the expected network micro-slot, the task in the second scheduling domain elastic pool is marked as a network congestion task and placed in the delayed retry queue. At the same time, its allocated but not yet used CPU time slice is transferred to other second scheduling domain elastic pool tasks whose network data is ready or which are purely computed locally. When the network data is ready, the network congestion task is rewritten into the ready execution sequence of the elastic pool dedicated kernel domain. The elastic resource pool scheduling result is generated based on the task completion status, network congestion status, and resource reclamation status.

10. A bursty task elastic resource pool scheduling system for a computing network scheduling system, used to implement the bursty task elastic resource pool scheduling method for a computing network scheduling system as described in any one of claims 1-9, characterized in that, Includes the following modules: The admission normalization identification module is used to perform admission normalization identification on sudden tasks entering the core scheduling layer, and synthesize the load level, estimated execution time, network data dependency status and feature integrity into a sudden task admission description, and write the sudden task admission description into the queue of sudden tasks to be scheduled. The dual-domain routing decision module is used to generate a dual-domain routing resource plan based on the burst task admission description, the current idle window of the real-time dedicated core domain, the dynamic security time boundary, and the available resource status of the elastic pool dedicated core domain. The burst tasks that meet the admission conditions of the first scheduling domain are configured as the idle window reuse tasks of the first scheduling domain, and the burst tasks that do not meet the admission conditions of the first scheduling domain or have incomplete characteristics are configured as elastic pool tasks of the second scheduling domain. The scheduling execution management module is used to run the idle window reuse task of the first scheduling domain in the first scheduling domain through a two-level scheduler driven by a hardware timer in accordance with the dual-domain routing resource plan, and to perform forced reclamation when the dynamic safety time boundary is reached; it is also used to allocate the elastic pool tasks of the second scheduling domain to the elastic resource pool composed of CPU time slices, large page memory slices, network micro time slots and cache partitions for continuous operation in the second scheduling domain, and to generate the elastic resource pool scheduling result based on the task completion status, network blocking status and resource reclamation status.

Images