CN105700941B

CN105700941B - The dispatching method of three-dimensional scheduler model

Info

Publication number: CN105700941B
Application number: CN201511027081.5A
Authority: CN
Inventors: 黄姝娟; 容晓峰; 刘白林; 张雅; 茹媛
Original assignee: Xian Technological University
Current assignee: Xian Technological University
Priority date: 2015-12-18
Filing date: 2015-12-18
Publication date: 2019-04-05
Anticipated expiration: 2035-12-18
Also published as: CN105700941A

Abstract

The invention discloses a kind of dispatching methods of three-dimensional scheduler model, after analyzing the time determinability of various types of real-time tasks, safety, reliability, all kinds of real-time tasks models are converted to unified 3 D stereo hierarchical relationship model, it is scheduled the adjustment of strategy further according to the level where task, finally maps that in two-dimension time-space figure corresponding with core.The strategy will not only consider load balancing to promote the parallel execution efficiency of multicore but also to be able to satisfy real-time, reliability and security requirement during task execution.In addition, the model and algorithm also study the shared resource synchronization mechanism of various real-time tasks, a kind of new shared resource Managed Solution is developed, to reduce the generation of deadlock and prevent CPU hunger phenomenon.

Description

Scheduling method of three-dimensional scheduler model

Technical Field

The invention relates to the field of embedded systems, in particular to a scheduling method of a three-dimensional scheduler model.

Background

Since the first embedded Multi-core processing ARM11MPcore in the world was introduced by ARM corporation and cambridge in england in 2004, Chip Multi-Processors CMP (Chip Multi-Processors) have quickly become a strong driving force in the field of embedded applications by virtue of the characteristics of small size, low communication delay, short design and verification period, high frequency, low power consumption, low cost and the like.

At present, multiple cores are widely applied to various devices, but the development of software is far behind the development of hardware, especially the scheduling and decomposition of tasks in an embedded system directly affect the normal use of system software, and the current embedded operating systems supporting multiple cores are all directed to a single type of real-time tasks, or only consider periodically executed real-time tasks, or only consider once executed non-periodic real-time tasks. There is currently no research aimed at multiple mixed types of real-time tasks. In this case, the multi-core system has problems that the system utilization rate is not high, or the system security cannot be guaranteed. Therefore, under the condition that the core number of the current multi-core chip is increased rapidly, how to improve the software parallel efficiency as soon as possible and accelerate the application of the multi-core computation in the embedded system is the most crucial and urgent problem. The project follows the hot problem of multi-core computing research and researches the scheduling, decomposition and synchronization mechanism problems of various real-time tasks in the embedded system. The method can not only improve the system efficiency and accelerate the application of the multi-core in the embedded system, but also meet the current requirements of national defense and military science and technology development.

However, the performance of the multi-core processor is mainly improved due to the increase of the number of the on-chip processor cores, and the potential parallel performance of the multi-core processor is mainly dependent on the development of multi-core software. Most of the current embedded software is developed based on a single-core system, and takes a single type of real-time task (such as a periodic task or a non-periodic task) as a design idea, and the execution process is serial. With the complexity of task types processed by embedded systems, the adoption of original software has many problems in real-time performance, reliability and safety. For example, different types of real-time tasks apply for the same resource at the same time, due to the uniqueness of the original system task scheduling scheme, the expected time is exceeded because of waiting according to rules, the requirement on the real-time performance of the tasks cannot be met, and the completion of safety-critical tasks cannot be guaranteed, so that the reliability of the system is reduced, major accidents are caused, and irreparable loss is caused. Research on improving software reliability and safety, effectively reducing the probability of software errors, and providing more advanced scheduling schemes and synchronization mechanisms becomes the focus of embedded software multi-core computing research.

Then, under the embedded multi-core platform, how to divide multiple types of serial tasks into parallel tasks and map the parallel tasks to a limited number of cores to execute so as to improve the overall performance of the system; how to meet the requirements of real-time performance, high reliability and high safety under the condition of parallel execution of tasks is a problem to be solved. For example, in a single-core system, priority preemption scheduling is a common real-time task scheduling policy, but in a multi-core system, a low-priority task and a high-priority task are executed on different cores at the same time, which may cause the low-priority task to be executed first and the high-priority task to fail to meet the real-time requirement. Once this occurs for a mix-critical task, both high reliability and high security cannot be guaranteed. Second, there is a contention problem for the shared resources. The single core adopts a lock mechanism to access the shared data, once one thread acquires the lock, other threads have to wait for the lock operation, and under the multi-core architecture, due to the increase of the number of cores, the competition of the cores for the shared resources is aggravated. If a large number of locking mechanisms are adopted to access shared resources, deadlock and priority inversion phenomena are easily caused, and some CPUs are in a starvation state, so that the efficiency of multi-core parallel execution is greatly reduced. This will certainly become a critical issue affecting multi-core parallel computing performance and software expansion. One way to solve this problem is to reduce the access to shared data and convert synchronous computations into thread private computations. This approach is costly and still does not avoid deadlock. Another method is "Lock-Free" programming using atomic operations. However, the difficulty and complexity of lockless programming is very high, so the competition problem for shared resources is another great challenge for embedded system software.

In the embedded field, real-time performance and reliability are souls of the whole system, and system software is a powerful support for guaranteeing the characteristics. In the field of combining multi-core and embedded, in order to fully exert the advantages of multi-core, not only the details of load balancing, synchronization mechanism and the like need to be considered during scheduling, but also the guarantee mechanism of real-time performance, reliability and key tasks needs to be considered more importantly. This is certainly a huge challenge for current serially scheduled real-time embedded system software. At present, the research on the problems at home and abroad is in intense discussion, and various methods are endless, but most of the methods are carried out aiming at a single real-time task type, and a unified, complete and systematic integral solution is not provided. Therefore, a highly reliable and highly safe scheduling model and scheduling algorithm are inevitably researched according to the characteristics of various embedded real-time tasks.

The real-time scheduling model under the current embedded multi-core platform mainly aims at mutually independent real-time periodic tasks. The scheduling algorithms under this model have two broad categories: a global scheduling algorithm and a task division scheduling algorithm. The global scheduling algorithm has the advantages of high core utilization rate and the disadvantages of thread migration for load balancing, and the migration cost is high. The task division scheduling algorithm has the advantages of achieving load balance and enabling the core utilization rate to be low. Therefore, what method is adopted to achieve both the core utilization rate improvement and the load balancing is a focus of research in the industry. To this end, current researchers employ two approaches: one approach is to consider task partitioning as a binning problem and set up various task partitioning conditions by employing heuristic methods to improve core utilization. However, how to set up task division conditions to optimize the core utilization rate becomes a difficult problem; the other is to combine task partitioning with global to reduce migration overhead. However, how to combine the core utilization rate can be improved, the load is balanced, and the overhead is small, which becomes a difficult point.

Current hybrid key task scheduling algorithms fall into three broad categories: (1) a task scheduling method based on priority. The method has low system utilization rate and cannot prevent the phenomenon of key level inversion; (2) scheduling algorithm based on resource task division. The algorithm is relatively complicated to implement, and has high requirement on the core processing speed under the condition of meeting the requirement that the task time limit is not lost; (3) the scheduling algorithm based on the sleep-aware requires that the sleep time of each task is calculated for multiple times, the calculation process is complicated, the time complexity is high, and only a small part of task sets can be scheduled by the zero-sleep method.

In the conventional real-time task scheduling process, a locking mechanism is generally adopted for the access of the tasks to the shared data, and the locking mechanism can cause deadlock and priority overturn phenomena. If applied in a hybrid critical system, it may also cause critical level flipping phenomena.

The studied problems of multi-core task allocation and scheduling, synchronization mechanism and the like are one of the important problems of multi-core computing in the embedded system. Although some studies at home and abroad are carried out at present, the comprehensive consideration is not carried out, and the ideal condition is achieved. Because various real-time tasks exist in the embedded system, such as safety critical tasks, mixed critical tasks, periodic tasks, non-periodic tasks and sporadic tasks and pipeline tasks, all the tasks may exist in the same complex system at the same time. Most of the current researches are directed to one or two researches, the whole researches are not planned, and the scheduling methods of the different types of real-time tasks are not uniformly applied to the comprehensive platform. In addition, with the increase of task types, the management of shared resources is also troublesome, because multi-core aggravates resource competition, and multiple types of tasks have different characteristics, so that how to solve the problem of good resource allocation and synchronization also needs to be carefully studied. If the problems are solved well, the efficiency of the multi-core in the embedded system is greatly improved, so that the technical development of China in various real-time fields such as national defense, aviation, aerospace and the like is greatly accelerated, the development in the embedded field is greatly promoted, and the method has an important technical promotion effect on the current and future technological development of China.

Disclosure of Invention

In order to solve the above problems, the present invention provides a scheduling method of a three-dimensional scheduler model.

In order to achieve the purpose, the invention adopts the technical scheme that:

the scheduling method of the three-dimensional scheduler model is characterized in that the three-dimensional scheduler model adopts a three-dimensional coordinate space (x, y, z), wherein an x axis represents time required by execution of a job of a real-time periodic task, a y axis represents a time value of execution starting of the job of the real-time periodic task, and a z axis represents a CPU number to which the real-time periodic task is possibly allocated, and specifically comprises a Sporadic task model, a PPT model and a mixed key task model.

The Sporadic task model, the PPTT model and the mixed key task model are combined together through a real-time period task model node, and the model has the following characteristics:

a. each periodic task is a triplet τ_i＝(Ф_i，E_i，D_i). Wherein, phi_iIs the task arrival time, E_iRepresenting worst execution time WCET, D_iRepresenting a task time limit;

b. task per cycle τ_iAll contain an infinite operation (job), and τ_jkDenotes τ_iThe k-th job of (1). r is_ikAnd d_ikRespectively represent tau_ikThe release time of (a) and the absolute time limit time of the kth job;

c.U(τ_i)＝E_i/D_idenotes τ_iA utilization factor of the task. Thus, for a periodic task, the total utilization of the system isLet σ be the maximum achievable utilization of the task, σ ═ max { U (τ)_i) Is obviously sigma e (0, 1)]；

The scheduling algorithm of load balancing adopted by the Sporadic task model is as follows:

theorem a gives a set of n periodic tasks, τ ═ τ₁，τ₂…，τ_nIn which τ is_i＝(E_i，D_i) A sufficient requirement that the DD algorithm can be scheduled using time-driven is

The periodic tasks complementary to theorem B must be schedulable on the same processor core, and the utilization ratio of the processor core is 1.

Proving the existence of k complementary periodic tasks tau₁＝(Ф₁，E₁，D₁)，τ₂＝(Ф₂，E₂，D₂)，…，τ_k＝(Ф_k，E_k，D_k) And then, from definition 2 to 7Then, according to theorem 2-1, it can be known that these tasks are scheduled on the same processor core by a scheduling algorithm of the time-limit driven dd (deadline driver), which is certainly satisfied, and the processor core is always in an execution state, so its utilization rate is 1.

The theorem C sets that k periodic tasks are distributed on one core, the k periodic tasks meet the proposed assumed conditions, and if the total utilization rate of the processor cores of the k periodic tasks is less than or equal to 1, a time period [0, T ] is necessarily existed, wherein T is the least common multiple of the time limit of the k periodic tasks. If k tasks can be scheduled within this time period, then these k tasks must be scheduled on the system.

It turns out that T is the least common multiple of the task time limit for k cycles. If k tasks are in this time period 0, T]Can be scheduled, then [ i T, (i +1) T]The scheduling method may be repeatedly performed for a period of time (i ═ 1, 2, L L, n), and so on, and the k periodic tasks may be scheduled periodically in a loop. Because of the fact thatSo it must be scheduled within this time period, as seen by theorem a.

The theorem D is that for any of the spadic tasks τ '(Φ', E ', D'), where Φ 'is the time when it arrives, E' is the time unit it must execute, and D 'is the time limit of the spadic task, let Δ ═ D' - Φ ', then the sufficient requirement that the spadic task can be scheduled within the Δ interval is Space (Δ) ≧ E'.

Proving the first-approved sufficient conditions: when the Space (Δ) ≧ E ', it means that there is a time unit E ' satisfying the execution of the spacial task in the Δ ═ D ' - Φ ' time interval, and therefore the execution can be completed before the time limit D ', and therefore the scheduling can be performed.

The secondary certificate requirements are as follows: if a task is to be executed within the time interval Δ ═ D '- Φ', then there must be spare time units to execute the Sporadic task, and the spare time units within this intervalIf E ' is greater than or equal to E ', Space (Delta) ≧ E '.

S11, judging whether the input one-cycle task set is an over-full utilization rate system, if so, outputting and being incapable of being called; otherwise, executing the second step;

s12, dividing the task set into two large subsets, namely a high utilization set S according to the task utilization rate^HAnd low utilization set S^LWhereinWhere i, j are both positive integers;

s13, corresponding S^HSelecting M-1 tasks tau with highest utilization rate in set₁，τ₂…τ_M-1Respectively distributed to M-1 cores and then from S^LSelect and in the set₁，τ₂…τ_M-1Set s of tasks that are complementary or nearly complementary (choosing ε minimum)₁，s₂…s_M-1Respectively distributing the data to the queues of M-1 cores correspondingly; if S is^HLess than M-1 tasks in the set, then at S^LFinding out complementary or approximately complementary task groups in the set and respectively distributing the complementary or approximately complementary task groups to the rest cores;

s14, according to theorem B and theorem C, it can be known that tasks in respective scheduling queues are scheduled on M-1 cores by applying a DD scheduling algorithm of theorem A;

s15, calculating the M-1 cores residual available Space in the period delta from the arrival time to the deadlines of the spadic tasks tau '(phi', E ', D') according to the theorem D_i(Δ), i ═ 1, 2, …, M-1. If the execution time Space of the Sporadic task_i(Δ) ≧ E' it can be assigned to the ith core. If none is satisfied, the task cannot be scheduled;

m kernels in the model respectively correspond to M planes of a z axis, wherein M-1 planes have s₁，s₂…s_M- ₁And M-1 sets, and respectively mapping the start time and the end time of the execution of the job initiated by the task in each set periodically to the x axis and the y axis of the three-dimensional scheduler model. The shaded portion is the execution period of each joba. If there is a non-shaded area between two jobs, it indicates the remaining available Space_i(Δ), i ═ 1, 2, …, M-1. Jobs assigned to the Sporadic task.

The PPTT model adopts a processor pre-allocation algorithm, and the specific steps are as follows: assuming that the number of processor cores is m, the processor pre-allocation algorithm can be described as follows:

s21, respectively generating corresponding expansion diagrams for n ST trees in a task system, putting the first job in each expansion diagram into a ready queue, selecting m jobs with high priority to be distributed to m cores to be executed according to priority judgment, and selecting n cores to be executed if the number n of jobs is less than m;

s22, after one job is executed, putting the jobs which can be executed in parallel on the back diagonal line into the ready queue, and calculating the time of executing the job of each task on the current coreA value ifThe job is indicated to have been executed, and is deleted in the corresponding task expansion map and ready queue. If it is notIf the operation is not completed, the time slice required to be executed by the operation is changed toAnd put this job into ready queue again and wait to schedule with other jobs;

and S23, recalculating the priority of each task in the ready queue, and selecting m tasks to be respectively distributed to m cores to run. If the number n of the jobs is less than m, selecting n cores to execute;

s24, repeating the steps S22 and S23 until all the jobs can be distributed to the cores to be executed;

and aiming at the nodes of each ST tree in the PPT model, m planes are formed according to the scheduling algorithm, and the operation in the task expansion diagram is mapped to the m planes respectively according to the scheduling sequence, and the starting execution time and the ending time of each jobis still mapped to an x axis and a y axis respectively.

The mixed key task model comprises a jobmodel, a task model and a system model, and the adopted algorithm is as follows:

theorem E assumes scheduling on the same core, and without considering the overhead of context switching and interrupts, a scheduling scheme for a set of tasks, Job J, arriving at the same time_iA sufficient requirement that can be scheduled successfully is that the job should have a period greater than or equal to the sum of the execution time of its previously executed task and the time value that the task needs to execute.

Proof of 1) necessity to make the execution order of a certain set of jobs J₁，J₂，L，J_nSetting the time of finishing the execution of each task as a₁，a₂，L，a_nIf all tasks can meet the time limit, the issuing time of the former task is the starting execution time of the latter task because no extra overhead is calculated. Therefore it has the advantages of

a₁＝r₁+c₁≤d₁

a₂＝a₁+c₂＝r₁+c₁+c₂≤d₂

a₃＝a₂+c₃＝r₁+c₁+c₂+c₃≤d₃

……

a_n＝a_n-1+c_n＝r₁+c₁+c₂+…+c_n≤d_n

d_n＝p_n+r_n

Since they arrive at the same time, r_n＝r₁By combining the above formula, can be obtained

Thus, it was confirmed.

2) Sufficiency if the period of each job is greater than the sum of the execution times of the tasks executed before the job, and any job period is greater than the sum of the execution time of the job and the execution time of the job executed before the job, then the period of any job is greater than the sum of the execution times of the job and the job executed before the job

This indicates that the execution of any one task has not exceeded a time limit and so can be scheduled. This theorem proves the syndrome.

For a job that arrives non-simultaneously, the condition of determining whether it can be scheduled is divided into two cases:

in the first case: when r is satisfied_i＜a_i-1When i is 2, L, n, there are

a₁＝r₁+c₁≤d₁＝r₁+p₁

a₂＝a₁+c₂≤d₂＝r₂+p₂

……

a_n＝a_n-1+c_n＝r₁+c₁+c₂+…+c_n≤d_n＝r_n+p_n

When it is satisfied withIt can be successfully scheduled.

In the second case: when r is_i≥a_i-1When i is 2

a₁＝r₁+c₁≤d₁＝r₁+p₁

a₂＝r₂+c₂≤d₂＝r₂+p₂

……

a_n＝r_n+c_n≤d_n＝r_n+p_n

When c is going to_i≤p_iThen the scheduling can be successfully performed.

S31, calculating key factors of each joba at different levels, performing priority ranking according to the sizes of the key factors, and judging whether the joba can be scheduled on the same core according to a theorem E;

s32, checking whether the key level is converted or not, if so, calculating the key factor of each joba according to the converted current level, determining a new priority order, comparing the new priority order with the priority order before conversion, and recording the jobs with the advanced priorities and the subsequent jobs without the advanced priorities;

s33, it is determined according to theorem E whether the job after the job whose priority is not pushed back can be scheduled on the same core. If possible, the earliest execution window W is calculated according to the release times of the jobs and the worst execution time at each level_i ^e(forward time-slicing function) and latest execution time window W_i ^l(reverse time division function), and find their public idle time window, utilize public idle time window to schedule the subsequent job, if can't, can only distribute the processor core in addition;

and S34, if the key level is not converted, or the jobs with the pushed priority is not generated after the key level is converted, continuing to execute according to the scheduling sequence.

Wherein, the theorem E is that a certain scheduling scheme is to a task set, job J, which arrives at the same time under the assumption that the scheduling is performed on the same core and the overhead of context switching and interruption is not considered_iA sufficient requirement that can be scheduled successfully is that the job should have a period greater than or equal to the sum of the execution time of its previously executed task and the time value that the task needs to execute.

Aiming at different system key values, if the jobs can be scheduled on the same core, the mixed key task model is placed on the same plane, otherwise, the mixed key task model is placed on different planes, and the starting execution time and the ending time of each job are mapped to the x axis and the y axis of the plane respectively.

After the jobs in all the task models are mapped into the three-dimensional models, all the shadow areas are moved downwards, and a plurality of planes are merged on the same plane, wherein the ordinate represents a CPU number, and the abscissa represents a time value, so that the three-dimensional models can be converted into two-dimensional plane execution diagrams, and all execution sequences can be displayed in the two-dimensional diagrams. As shown in fig. 3.

The invention has the following beneficial effects:

after analyzing the time certainty, safety and reliability of various real-time tasks, various real-time task models are converted into a unified three-dimensional hierarchical relation model, then the scheduling strategy is adjusted according to the hierarchy of the tasks, and finally the scheduling strategy is mapped into a two-dimensional space-time diagram corresponding to the core. The strategy not only needs to consider load balancing to improve the parallel execution efficiency of multiple cores, but also needs to meet the requirements of instantaneity, reliability and safety in the task execution process. In addition, the model and the algorithm also research a shared resource synchronization mechanism of various real-time tasks, and a new shared resource management scheme is researched to reduce the occurrence of deadlock and prevent the phenomenon of CPU starvation.

Drawings

Fig. 1 is a three-dimensional model diagram in a scheduling method of a three-dimensional scheduler model according to an embodiment of the present invention.

FIG. 2 is a diagram of the execution time of job with CPU number 4 and the method for covering the shadow formed by the x-axis in the embodiment of the present invention.

FIG. 3 is a sequence diagram illustrating the conversion of a three-dimensional model into a two-dimensional execution according to an embodiment of the present invention.

FIG. 4 is a diagram illustrating a scheduler model according to an embodiment of the present invention.

FIG. 5 is an expanded view of the ST tree real-time periodic task in the embodiment of the present invention.

Fig. 6 is a main flow chart of system scheduling according to an embodiment of the present invention.

Fig. 7 is a scheduling scheme of a shared priority queue according to an embodiment of the present invention.

FIG. 8 is a two-layer Bloom Filter design in accordance with an embodiment of the present invention.

FIG. 9 is a general flow chart of algorithm execution in an embodiment of the present invention.

FIG. 10 is a Bloom Filter locking process in an embodiment of the present invention.

Detailed Description

In order that the objects and advantages of the invention will be more clearly understood, the invention is further described in detail below with reference to examples. It should be understood that the specific embodiments described herein are merely illustrative of the invention and are not intended to limit the invention.

As shown in fig. 1, an embodiment of the present invention provides a scheduling method for a three-dimensional scheduler model, and the scheduling method for the three-dimensional scheduler model is characterized in that the three-dimensional scheduler model uses a three-dimensional coordinate space (x, y, z), where an x axis represents a time required for completing execution of a job of a real-time periodic task, a y axis represents a time value for starting execution of the job of the real-time periodic task, and a z axis represents a CPU number to which the real-time periodic task may be allocated, as shown in fig. 1.

Mapping a scheduling sequence formed by the three different scheduling models and scheduling algorithms into a three-dimensional space model for scheduling, wherein the method comprises the following steps: and mapping the time for starting execution and the time required for finishing execution of each jobin the scheduled scheduling sequence to the x axis and the y axis of the plane with the z being 1 respectively, and moving to the next z plane if a superposed part occurs. And the start execution time and the time required for completion of execution of the same job and the x-axis are taken as the plane shadow part. This section indicates the execution period of the job. As shown in fig. 2, a plane map having CPU number 4.

Examples

Real-time periodic task model

Assume a system with M cores (M > 1) and the cores are homogeneous. In the following, n periodic tasks τ ═ { τ ═ is performed₁，τ₂，LL，τ_nAnd k Sporadic tasks τ '═ τ'₁，τ′₂，L L，τ′_kThe preemptible scheduling problem on homogeneous multi-core processors is discussed as an example.

The periodic task has the following characteristics:

1) one triplet τ per task may be used_i＝(Ф_i，E_i，D_i) And (4) showing. Wherein, phi_iIs the task arrival time, E_iRepresenting worst execution time WCET, D_iIndicating task deadlines.

2) Tasks can be preempted and are independent of each other, and the overhead caused by task switching on the same core and the access overhead of other resources such as variables, buffers and the like are not considered.

3) Task per cycle τ_iAll contain an infinite job joba, and τ_ikDenotes τ_iThe k-th job of (1). r is_ikAnd d_ikRespectively represent tau_ikAnd the absolute dead time of the kth job.

4)U(τ_i)＝E_i/D_iDenotes τ_iA utilization factor of the task. Thus, for a periodic task, the total utilization of the system isLet σ be the maximum achievable utilization of the task, σ ═ max { U (τ)_i) Is obviously sigma e (0, 1)]。

Suppose that any Sporadic task is lower in priority than a periodic task and is a triplet τ'_i＝(Ф′_i，E′_i，D′_i) Wherein, phi'_iIs arrived atEtched E'_iDenotes the worst calculated time, D'_iIndicating the corresponding deadlines. Defining instantaneous utilization rate of Sporadic task as U (tau'_i)＝E′_i/D′_i，U′_i∈(0，1]。

The multinuclear model is described as follows: p ═ P₁，P₂L L，P_Mη is a set of M processor cores with the same processing capability_iIs the ith core P_iI.e. the total utilization U of the tasks assigned to the core_i. In addition, it is assumed that task scheduling is performed in a preemptible manner and execution can be resumed immediately after interruption.

The Sporadic real-time period task scheduler model adopts a central scheduler and an edge processor core model, namely a core is used as a special scheduler. All tasks arrive at the central scheduler and are then distributed to the edge processor cores in the system by the scheduling algorithm for execution, as shown in fig. 4. And each edge processor core has its own Dispatch queue. Thus, after it has completed executing the current task, it takes a task from its dispatch queue for execution. After the scheduling queue of the edge processor core is executed, the edge processor core informs the central scheduler, and the central scheduler distributes the new task to the scheduling queue of the edge processor core again according to the algorithm and modifies the scheduling queue of the central scheduler.

PPTT model

To define the PPTT model, the relationships between nodes in the DAG graph are first defined.

3-3 (execution order relationship) for nodes A and B of any two different tasks in the DAG graph, if A exists in the precursor node set of B, the A and B are said to have a sequential execution order relationship, that is, A must be executed before B starts.

Defining 3-4 (replication relations) for any one of the DAG graphs that has a successor node (also called fork node) A, it is possible to assume that there are n successor nodes for ATo form A by copying the A node n-1 times₁，A₂，…，A_n-1And A, the n nodes respectively correspond to n different successor nodes, so that the fork node can be eliminated. At this time, the n nodes A are called₁，A₂，…，A_n-1There is a copy relationship between a.

Defining 3-5 (Merge relation) for any node A in DAG graph with predecessor (also called jojn node), if there are m predecessor nodes of A, the node can be split into different nodes A₁，A₂，…，A_mRespectively corresponding to different predecessor nodes. At this time, the m nodes A are called₁，A₂，…，A_mThere is a merging relationship between them.

Definition 3-6 (independent relationship) if the above three relationships do not exist between two nodes a and B, the two nodes are said to be independent of each other.

Definitions 3-7 in the STF, only nodes on the same level have copy and merge relationships between them. Different ST trees with a copy relationship and a merge relationship are referred to as a single tree with a copy association relationship or a merge association relationship.

Definitions 3-8 k ST trees are said to have an independent relationship if they have neither a merged nor a duplicate association. Nodes on different ST trees with mutually independent relations are mutually independent.

Defining a 3-9 parallel priority task tree PPTT model may be represented by a two-tuple PPTT ═ (STF, R). Wherein STF is the set of STs; r is used to define the relationship existing between any two nodes in the ST, including the execution sequence relationship, the copy relationship, the merge relationship and the mutual independent relationship.

Processor pre-allocation algorithm

Before pre-allocation of processors, task nodes of each ST in the STF model are firstly operated according to periodic tasksThe form is expanded as shown in fig. 5.

From fig. 5, it can be seen that the dependency relationship between the tasks in the expanded graph is not present between the tasks connected by the dotted lines on the diagonal lines, and the predecessors thereof can be executed in parallel when the execution is finished. Assuming that the number of processor cores is m, the processor pre-allocation algorithm can be described as follows:

the present application assumes that the overhead due to task replication is ignored when performing the processor pre-allocation algorithm. When cores are distributed, single trees where node tasks with a combination relation are located are distributed to the same core to be executed as much as possible, and therefore synchronous communication overhead is reduced. Under the condition that the number of the processor cores is the same as that of the tasks, the processor performs pre-allocation according to the following principle:

(1) each ST tree in the STF is allocated to a different core for execution.

(2) In order to reduce the merging times in turn, the nodes with the merging relation are distributed to the same core as much as possible to execute.

(3) And scheduling according to the priority execution relation during scheduling.

The main flow chart of system scheduling is shown in fig. 6.

Hybrid mission critical model

Including the jobmodel, task model, and system model.

jobmodel

The key levels in a mixed-key system have two layers of implications: first, the entire system itself has a critical level at different times; second, each jobhas a corresponding key level at different times. In a mixed-critical system with a total of k levels, a joba can be represented by a 4-dimensional vector: j. the design is a square_j＝(r_j，d_j，x_j，c_j) Wherein r is_jRepresents the arrival time of the job, namely the release time; d_jRepresents the death limit of job, obviously, d_j＞r_j；x_jE {1, 2, … …, k } refers to the key level of the job at a certain moment, and at a certain moment, its value is also determined; c. C_jThen represents a k-dimensional vector: c. C_j＝{c_j(1)，c_j(2)，……，c_j(k) Represents the worst execution time of the job at each level, wherein c is assumed_j(1)≤c_j(2)≤…≤c_j(k) In that respect For each job in a task set, to ensure the characteristics of the real-time system, the execution must be completed before the deadline comes, that is, the actual execution is completed at a time less than the deadline.

For a set of n jobs, there must be a corresponding actual execution time vector: (c)₁，c₂，…，c_n) Wherein c is_jRepresenting the actual execution time of the jth jobi. For this particular vector, the key level of the system is the smallest integer value l (l ∈ {1, 2, …, k })) that ensures that for each current jobof the system, the following relationship holds: c. C_j≤c_j(l) (j ∈ {1, 2, …, n }). Here, only those sets of system jobs that can find such a value/value are studied.

In combination with the above-mentioned 4-dimensional definition of the job and the determination of the key level of the system, it is easy to find that if the current system is at/at the key level, all job jobs at/at or above/at the level must be executed before the deadline time comes in during the operation of the whole system. I.e. firstly to guarantee the execution of the/level or greater/level tasks and secondly to consider the execution of the less/level tasks.

task model

In a mixed mission critical system with k levels, each task (task) can be represented by a 3-dimensional vector: t is_i＝(c_i，p_i，x_i). Wherein, c_iAs in the jobmodel, is a k-dimensional vector for the respective tableShowing the worst execution time of the task at each level, i.e. c_i＝{c_i(1)，c_i(2)，……，c_i(k)}；p_iThe execution period of the task is shown, and the execution period is also the shortest time interval of two successive times of job release; x is the number of_i(x_iE {1, 2, …, k }) represents the level at which the task is located, as well as the jobmodel, whose value is determined at a certain time. Also, in the task model, for c_iLet c be_i(1)≤c_i(2)≤…≤c_i(k)。

In the hybrid safety-critical task model, each task T_iAn infinite number of jobs can be implied, with these jobs every p_iEach time interval is issued and executed once. In this model, after each jobs release, its release time r_iIt is determined that its deadline is specified to pass p when the jobs issues_iAt a later time, i.e. d_i＝r_i+p_i. As for the key level, the key level of the job is the same as that of the task, i.e. x_i. C of these jobs_iC with the task_iAgain, consistent. Therefore, according to the 3-dimensional vector of task, all the issued job's 4-dimensional vectors can be determined, and the parameters of the job's can be determined comprehensively, so that the job's can be scheduled according to the scheduling algorithm described later.

System model

In a mixed mission critical system with k levels, let T ═ T₁，T₂，…，T_nRepresents the set of tasks in the system. Since the loop mission system is mainly studied herein, it is assumed hereinafter that there are n tasks in total in one loop in the hybrid mission-critical system: t is_i＝(c_i，p_i，x_i) (i-1, 2, …, n), wherein c_iRepresenting a worst execution time for the task; p is a radical of_iIndicating the execution period of the task; x is the number of_iRepresenting the level of criticality of the task in this hybrid critical tasks system. Let J be { J ═ J₁，J₂，…，J_mRepresents the job set in the system, namely m job sets need to be executed in one cycle of the mixed mission-critical system. Each joba can also be represented as J_j＝(r_j，d_j，x_j，c_j) (j is more than or equal to 1 and less than or equal to n). Wherein r is_jRepresents the release time of the jobs; d_jRepresenting the deadlines of the jobs, and being obtained by calculating the release time and the worst execution time of the jobs; x is the number of_jThe key level of the job is consistent with the current key level of the task. c. C_jIs a k-dimensional vector representing the worst execution time of the job at different key levels, which is obtained from the worst execution time of the key task to which the job belongs.

Hybrid critical scheduling algorithm design and implementation

Define the earliest possible execution time of 4-1- - - -means J_iThe time at which the idle processor core is obtained is allowed to be the earliest.

Define 4-2 the latest starting execution time- - - - -means J_iMinus the worst execution time it needs to execute, i.e. the time value

Defining 4-3 latest execution window- - - - -means J_iThe time from the latest execution start time to the absolute dead limit is its latest execution window, i.e. the time of execution

Definition 4-4 earliest executionLine completion time O_i- - - - -means J_iThe earliest time of execution plus the maximum time of execution it requires, i.e. the value

Defining 4-5 earliest execution window- - - - -means J_iFrom the earliest permitted execution time to the earliest finish time, i.e.

Defining 4-6 idle executable windows- - - - -means if J_iMay be executed at the earliest possible completion time O_iLess than the latest execution start timeThen this time is called an idle executable window, i.e. a

Defining 4-7 relative criticalities ρ_i- - - - -means a jobJ_iThe key level importance relative to other jobs. By usingTo indicate.

Defining 4-8 key quota delta_i- - - - -means a jobJ_iKey number of copies that can be at k key levels. By usingTo indicate.

Definition of 4-9 Key factors- - - - -means a jobJ_iA measure of the key level importance and utilization of an execution at a certain level relative to the execution of other tasks. By usingIs shown, andwherein,is J_iUtilization at the k level.

The scheduling algorithms of the three models are executed according to the jobs, the latest starting time or the earliest starting time is used as a vertical coordinate, the time limit of the jobs is used as an abscissa, the corresponding CPU number is used as a third coordinate, the third coordinate can be mapped into the corresponding three-dimensional scheduling model, and the three-dimensional scheduling model can be mapped into the two-dimensional plane graphs of the CPU and the time node by moving the shaded part downwards and combining different plane graphs.

Specific implementation method of three-dimensional scheduling model in real-time system scheduling process and overall design of synchronization mechanism

The method and the device adopt a mechanism combining lock and free-lock to realize scheduling and synchronization of the real-time periodic tasks in the execution process. The method specifically comprises the steps of judging the running state of the selected job by using a Bloom Filter based on a lock, and realizing an improved Skip-list data structure based on a lock-free algorithm to store a task to be scheduled and the blocked job. The system design is shown in fig. 7.

In this scenario, the vertical list of Skip-list is meaningful differently for different models. For example, the longitudinal lists of Skip-list for the Sporadic task model can be regarded as different types of periodic tasks such as fixed period and indefinite period, the 2-level longitudinal lists of Skip-list for the PPTT task model can be regarded as different ST trees, and the 2-level longitudinal lists of Skip-list in the mixed key task model can be regarded as different key levels. When the property of a certain periodic task changes, for example, a fixed periodic task in a Sporadic model is converted into a Sporadic periodic task, a periodic task in a PPT model is converted from an ST tree into a task on another ST tree, and a key level in a mixed key model is converted from a low level to a high level, the task is converted in different longitudinal lists, for example, the linked list of the low key level hierarchy is upgraded into the linked list of the high key level hierarchy. The nodes in the Skip-list are increased into two types: one is a periodic task node, and the other is a job node on which a task is suspended.

When a high-priority task on a certain processor core preempts a low-priority task, the executing low-priority job is suspended, the suspended job is put into a corresponding position in the Skip-list according to the conversion property and the priority order, and the access of all cores to the Skip-list adopts a lock-free algorithm. The second is to inquire the Bloom Filter of the task state to inquire whether the job at a certain moment of a certain periodic task is in four states of ready, executing, suspending and finishing. The following is an example of a hybrid mission critical model:

for a system with n mixed key tasks of k key levels, a global scheduling algorithm is adopted to schedule the key tasks to m cores for execution. In the overall scheduling process of the system, firstly, n mixed key tasks needing scheduling are inserted into a Skip-list data structure according to different key levels by using operations such as creation and insertion of the Skip-list data structure. Secondly, the idle core selects the task with the highest priority in the current key level from the Skip-list queue or the job to be suspended to be ready for execution. If the job is a suspended job, whether the deadlock loss occurs is judged, if so, the job is deleted, and the next task is selected. Otherwise, inquiring the state of the task to be scheduled or the job by the Bloom Filter, and if the task is in the non-execution state, taking out the task to be scheduled and executing the task; otherwise, selecting the job corresponding to the next task in the current key level from the Skip-list to prepare for execution. Thirdly, in the running process, if a high key level task (high priority task) is issued, preempting a processor core which is processing a low key level (low priority task), inserting a job of the low key level into the Skip-list linked list, and setting the corresponding job state in the Bloom Filter to be an unexecuted state. Finally, different cores may access the Skip-list data structure simultaneously.

The synchronization algorithm in the present application is implemented as follows. On the basis of a global priority scheduling algorithm, a lock-free access method and a Bloom Filter state query method are adopted for a priority queue Skip-list, and in the Bloom Filter, the most key technology is bit number selection and hash function setting. The purpose of the bit number selection is to map a large range of elements into a small range of bit numbers by a hash function. Assuming a certain set has u elements and a Bloom Filter has m bits, a corresponding hash function must be defined so that these u elements can correspond to some possible positions within a given range m. The selection of the Bloom Filter digit number and the selection of the hash function in the chapter are related to the number of tasks in a hybrid key system, and the Bloom Filter is improved into a multilayer structure.

In a real-time system, there are two purposes of using Bloom filters:

firstly, whether the job of a certain task belongs to a scheduled range is judged through the Bloom Filter so as to prevent a plurality of cores from executing the same job.

Secondly, judging the state of the current jobs through the Bloom Filter: whether to execute or not, it can be determined whether the accessed job is to be discarded or executed according to the state. The improved Bloom Filter is shown in FIG. 8.

Fig. 9 shows the overall scheduling flow. When a plurality of processor cores access the Skip-list at the same time, only one core can obtain the modification right of the Bloom Filter state bit corresponding to the hash function. When the other processor core knows that the job has executed, it will select the next task. Because the operations of inserting, deleting and modifying the Skip-list are all based on a lock-free synchronization mechanism, the parallel operation efficiency of the multi-core to the shared priority queue can be improved.

When the Skip-list priority queue is created, the release time of the current task needs to be updated, and after the creation is completed, the task can be extracted from the Skip-list, and the algorithm is as follows:

1) selecting a published task or a blocked job in the Skip-list;

2) judging whether the task or the block job is being executed or not through the Bloom Filter, and if so, reselecting a task node from the Skip-list task chain table;

3) if the task or the blocking job is not executed, whether the task or the blocking job exceeds the deadline time or not is continuously judged, if the task or the blocking job exceeds the deadline time, the missing deadline time of the task or the blocking job is output, the issuing time of the task is updated, the task is re-issued, and if the task or the blocking job is the blocking job, the job is deleted. Returning to the first step to reselect the task or block the job in the Skip-list task linked list;

4) and returning the tasks or the blocking jobs which are issued in the Skip-list linked list, have the state of not being executed and do not exceed the dead time.

On the Bloom Filter, the task or block job is identified as not running. In the whole scheduling process, the operation of the Bloom Filter mainly has the following aspects:

1) and calculating a secondary hash function value according to the job corresponding to the task, and determining the hash function by the Bloom Filter according to the number of the tasks. When the query state is a read process, a lock mechanism is not required for parallel memory read.

2) When the job can be scheduled, finding the corresponding position on the Bloom Filter according to the calculation of the secondary hash function value, if the position is 0, locking the position, directly writing the position into 1, and then unlocking. If the location is already 1, indicating that the job has been executed, a new callable job needs to be found.

3) When job is finished, marking the job as an un-run value 0 on a Bloom Filter according to the calculation of the secondary hash function value; and then unlocked. The flow of the Bloom Filter fine-grained locking process is shown in fig. 10.

After the three-dimensional model analyzes the time certainty, the safety and the reliability of various real-time tasks, the various real-time task models are converted into a unified three-dimensional hierarchical relation model, then the scheduling strategy is adjusted according to the hierarchy of the tasks, and finally the scheduling strategy is mapped into a two-dimensional space-time diagram corresponding to the core. The strategy not only needs to consider load balancing to improve the parallel execution efficiency of multiple cores, but also needs to meet the requirements of instantaneity, reliability and safety in the task execution process. In addition, the model and the algorithm also research a shared resource synchronization mechanism of various real-time tasks, and a new shared resource management scheme is researched to reduce the occurrence of deadlock and prevent the phenomenon of CPU starvation.

The foregoing is only a preferred embodiment of the present invention, and it should be noted that those skilled in the art can make various improvements and modifications without departing from the principle of the present invention, and these improvements and modifications should also be construed as the protection scope of the present invention.

Claims

1. The scheduling method of the three-dimensional scheduler model is characterized in that the three-dimensional scheduler model adopts a three-dimensional coordinate space (x, y, z), wherein an x axis represents the time required by the execution of the job of the real-time periodic task, a y axis represents the time value of the execution start of the job of the real-time periodic task, a z axis represents the CPU number possibly allocated to the real-time periodic task, and the scheduling method specifically comprises a Sporadic task model, a PPT model and a mixed key task model,

a. each periodic task is a triplet τ_i＝(Φ_i，E_i，D_i) Wherein phi is_iIs the task arrival time, E_iRepresenting worst execution time WCET, D_iRepresenting a task time limit;

b. task per cycle τ_iAll contain an infinite operation (job), and τ_ikDenotes τ_iThe k-th operation of r_ikAnd d_ikRespectively represent tau_ikThe release time of (a) and the absolute time limit time of the kth job;

c.U(τ_i)＝E_i/D_idenotes τ_iThe utilization factor of the task, the total utilization of the system for a periodic task is thenLet σ be the maximum achievable utilization of the task, σ ═ max { U (τ)_i) Is obviously sigma e (0, 1)]；

The scheduling algorithm adopted by the Sporadic real-time period task model is as follows:

The complementary periodic tasks of the theorem B are necessarily schedulable on the same processor core, and the utilization rate of the processor core is 1;

the theorem C is that k periodic tasks are distributed on one core, the k periodic tasks meet the provided assumed conditions, if the total utilization rate of the processor core of the k periodic tasks is less than or equal to 1, a time period [0, T ] is certain to exist, wherein T is the least common multiple of the time limit of the k periodic tasks; if k tasks can be scheduled within this time period, then the k tasks must be scheduled on the system;

s13, corresponding S^HSelecting M-1 tasks tau with highest utilization rate in set₁，τ₂…τ_M-1Respectively distributed to M-1 cores and then from S^LSelect and in the set₁，τ₂…τ_M-1Complementary or near-complementary sets s of tasks₁，s₂…s_M-1Respectively distributing the data to the queues of M-1 cores correspondingly; if S is^HLess than M-1 tasks in the set, then at S^LFinding out complementary or approximately complementary task groups in the set and respectively distributing the complementary or approximately complementary task groups to the rest cores;

s15, theorem D, for any of the spadic tasks τ '═ (Φ', E ', D'), where Φ 'is the time of arrival, E' is the time unit that it must execute, and D 'is the time limit of the spadic task, let Δ ═ D' - Φ ', then the sufficient requirement that the spadic task can be scheduled in the Δ interval is Space (Δ) ≧ E', and M-1 cores of the time Δ from the time of arrival to the deadlines of the spadic task τ '═ (Φ', E ', D') are calculated according to theorem D_i(Δ), i ═ 1, 2, …, M-1, if the execution time Space of the spaoradic task is_i(Δ) ≧ E' it can be assigned to the ith core, if none is satisfied, the task cannot be scheduled;

s22, after one job is executed, putting the jobs which can be executed in parallel on the back diagonal line into the ready queue, and calculating the time of executing the job of each task on the current coreA value ifIndicating that the operation is finished, deleting the operation in the corresponding task expansion diagram and ready queue, if so, deleting the operationIf the operation is not completed, the time slice required to be executed by the operation is changed toAnd put this job into ready queue again and wait to schedule with other jobs;

s23, recalculating the priority of each task in the ready queue, selecting m tasks to be respectively distributed to m cores to run, and if the number n of the tasks is less than m, selecting n cores to execute;

the hybrid key task model comprises a jobmodel, a task model and a system model, and adopts a scheduling algorithm based on key factors as follows:

s31, theorem E assumes scheduling on the same core without consideringConsidering the overhead of context switching and interrupts, a certain scheduling scheme is used for a set of tasks, Job J, that arrive at the same time_iThe sufficient necessary condition that the job can be successfully scheduled is that the period of the job is greater than or equal to the sum of the execution time of the previously executed task and the time value required to be executed by the task, the key factors of each job at different levels are calculated, priority ranking is carried out according to the size of the key factors, and whether the job can be scheduled on the same core is judged according to the theorem E;

s33, for the scheduling sequence of the jobs of the job with the priority not pushed, judging whether the job can be scheduled on the same core according to the theorem E, if so, calculating the earliest execution window W according to the release time of the job and the worst execution time of each level_i ^eAnd a latest execution time window W_i ^lAnd calculating their public idle time windows, scheduling the post-pushed jobs by using the public idle time windows, if not, only allocating processor cores additionally;

2. The scheduling method of the three-dimensional scheduler model according to claim 1, wherein the scheduling order formed by the three different scheduling models and scheduling algorithms is mapped to the three-dimensional space model for scheduling, and the method comprises the following steps: mapping the time for starting execution and the time for finishing execution of each jobin the scheduled scheduling sequence to the x-axis and the y-axis of a plane with the z being 1 respectively, if a superposed part exists, moving to the next z-plane, and starting execution time and the time for finishing execution of the same jobsAnd the x-axis is shaded as a plane indicating the execution period of the job; without considering the overhead of context switches and interrupts, some scheduling scheme is for a set of tasks, Job J, that arrive at the same time_iA sufficient requirement that the job can be scheduled successfully is that the period of the job should be greater than or equal to the sum of the execution time of the task that has been executed previously and the time value that the task needs to be executed, and the time corresponding to the maximum value of the x-axis of the shaded portion that the job has when being in the three-dimensional scheduling model is not greater than a given time limit indicates that the job can be scheduled in time.