scheduling algorithms for multiprogramming in a hard-real-time environments gracia yuen umum

Scheduling Algorithms for Multiprogramming in a Hard-Real-Time

Environments

Gracia Yuen

UM

Agenda Target of the presentation1

Background2

A Fixed Priority Scheduling Algorithm 3

A Deadline Driven Scheduling Algorithm5

A Mixed Scheduling Algorithm6

Algorithm Comparison 7

Conclusion8

• Discuss the proper algorithm of multiprogram scheduling for services in Hard-Real-Time environment on a single processor.

• Based on existed two ideas:

1. Fixed priority scheduling

2. Dynamically assigning priority scheduling.

try to find an optimum combination idea for the Hard-Real-Time services.

Target of the presentation1

Background2

Requirements & Background2-1

Definition of Concept2-2

2-3 Constraint Conditions of Modeling

1. Design is triggered requirements.

The rapidly increased computer use for Control&Monitoring of industrial processes.

2. The validity of embedded realtime system includes:

1) the correctness of the program logic;

2) meet the time constraint condition.

Background 2-1 Requirements & Background2

3. Based on the requirements of Real-Time, real-time system can be divided as:

1) Hard-real-time

it is mandatory to meet the deadline of response time;

2) Soft-real-time

a statistical distribution of response times is acceptable;


4. Based on scheduling, real-time system can be divided as:

1) Static Scheduling

Algorithms are based on RMS;

2) Dynamic Scheduling

Algorithms are based on EDF or LLF.


5. Based on Real-Time Scheduling, real-time system can be divided as:

1) single processor scheduling;

2) centralized multiprocessor scheduling;

3) distributed processor scheduling;


6. Based on whether or not preemption is available, real-time system can be divided as:

1) preemptive scheduling;

2) non-preemptive scheduling;

7. This paper is discussed Only on:

1) single process system;

2) preemptive scheduling;


2. Function

1) More than 1 functions on a computer;

2) Associated with a set of tasks;

3. Task

1) Time-driven;

2) Processes a fixed time to elapse/task.

=> service is guaranteed in the time.

3) Preemptive;

Background 2-2 Definition of Concept2

1. Task

1) Periodic task;

1> independent;

2> has deadline;

consist of run-ability constraints Only;

no queuing problem for individual task;

3> constant interval between tasks;• Note: Periodic task is one scenarios of tasks in time-

critical control & monitoring functions.

Background 2-3 Constraint Conditions of Modeling2

4> run-time of each task is constant;

run-time is an approximation value;

the maximum processing time for a task

task ti

tast requirest period: Tm;= 1/requiret-rate

2) Non-Periodic task;

1> Initialization or Failure RR;

2> no critical deadline;


2. Assumptions:• The requests for all tasks for which hard

deadlines exist are periodic, with constant interval between requests.

• Deadlines consist of run-ability constraints only – i.e. each task must be completed before the next request for it comes.

=>eliminates queuing problem for the individual task.


2. Assumptions:• The tasks are independent in that requests

for a certain task do not depend on the initiation or the completion of requests for other tasks.

• Run-time for each task is constant for that task and does not vary with time. Run-time here refers to the time which is taken by a processor to execute the task without interruption.


2. Assumptions:• Any non-periodic tasks in the system are

special; they are initialization or failure-recovery routines; they displace periodic tasks while they themselves are being run, and do not themselves have hard, critical deadlines.

• Delays caused by the single processor, the preemptive scheduling and task switching, are ignored.


3. Scheduling algorithms will be discussed:

1) Fixed priority scheduling

2) Dynamic priority scheduling:

priorities of tasks might change from request

to request.

3) Mixed scheduling algorithm

the priority of some tasks are fixed and others are vary from request to request.



Scheduling Algorithm Concepts3-1

Modeling3-2

3-3 Theorem & Proof:

3-4

3-5

Processor Utilization

Relaxing the Utilization Bound

1. Scheduling Algorithm Concepts:

1) Deadline of a request for a task (point of time)

the time of the next request for the same task;

if t is the deadline of an unfulfilled request,

=> an overflow occurs at t;

2) Critical Instant for a task (point of time)

is used to determine the algorithm;

If t = critical instant,

{a request for the task will have the largest

response time;}


3) response time of a request for a task (duration)

the time span= [t(request), t(the end of the response to the request)]

4) Critical time zone for a task (duration) the time interval = [t(a critical instant),

t(the end of the response to the corresponding request of the task)]



Obviously, the fixed one is a RMS algorithm. (Rate-Monotonic Scheduling)


2. Modeling:

1) Allocation of Priority:

Priority is inversely proportional to Period of request;

2) Schedulability Analysis

CPU Utilization: U = sum(Ci/Ti);

U<=1;

Otherwise, the tasks can not be scheduled in the single processor system.


2. Modeling:

3) Defination:

si is a period task and defined as si(Ti,Ci,Di);

Ti is the Request_Period of si;

= the reciprocal(the request rate) task with lower Request_Period will have higher Priority;

task with higher Rquest_Rate will have higher Priority;

Ci is the respective rum-times;(processor time spent)

Di is the end of the request period;

3. Theorem & Proof:

1)Theorem 1:

A critical instant for any task occurs whenever the task is requested simultaneously with requests for all higher priority tasks.

Proof:

The delay in the completion of si is the largest

when t2 coincide with t1;


Effect:

I. One of the values of this result is that a simple direct calculation can determine whether or not a given Priority assignment will yield a feasible scheduling algorithm.

If 1> it can schedule a set of tasks;

2> the requests for all tasks at their critical instants are fulfilled before their respective deadlines.

=> it is a feasible scheduling algorithm.



T1=2, T2=5

C1=1, C2=1

• (a) (T1 higher priority) Feasible

• (b) (T1 higher priority) C2 can be increased to 2

• (c) (T2 higher priority) C1 and C2 can be at most 1


• Q: In figure2, for task 2, plz answer below items:

deadline,

critical instant,

the end of respond end,

response time,

critical time zone?

My understanding:

as the critical time zone in Figure 2, for task2, the end of the response is 5, actually task2 is finished to response at 2. right?

a new request can come at t=5, => 5 is deadline.


• A1, all the tasks have periodic requests, • A4, run-times is constant.• => otherwise,

critical time zone can be defined as the time zone between its request and deadline, if the task has the highest priority.

Effect:

II.Every fixed priority assignments rule can be scheduled by the RMPA(rate-monotonic priority assignment).

Reason: Precondition is (T1==2) < (T2= 5);

1) Priority(S1) > Priority(S2);

need to meet: (T2/T1)*C1 + C2 <= T2

Request_Rate(S1) > Request_Rate(S2);

2) Priority(S1) < Priority(S2);

need to meet: C1 + C2 <= T1, Or:

(T2/T1)*C1 + (T2/T1)*C2 <= (T2/T1)*T1 <= T2

=> the algorithm is feasible for both of the two cases.


Effect: => More generally,

the rule of Priority assignment is to assign priority to tasks according to their Request_Rate, independent of their of their run-times(C1,C2);

=> task with higher Request_Rate will have a higher Priority. Or,

task with lower Request_Period(T1,T2) will have a higher Priority.


Effect: for(T1==2) < (T2= 5);

=> Request_Period(T1) < Request_Period(T2)

=> S1 has higher Request_Rate;

=> S1 has a higher Priority;

The way to assign Priority to tasks is called: RMPA(Rate Monotonic Priority Assignment)

The algorithm of RMPA is called:

RMS(Rate-Monotonic Scheduling)


3. Theorem & Proof:

2) Theorem 2:

If a feasible priority assignment exists for some task set, the rate-monotonic priority is feasible for that task set.

If a static scheduling algorithm exists for some task set, RMS is feasible for the task set.


Proof: Exchange Algorithm

1> Assumption:

If a static scheduling algorithm, RMS1, exists for some task set;

Sa,Sb is 2 tasks of adjacent priorities in the task set, and Priority(Sa)> Priority(Sb),

But, Request_Period: Ta > Tb


2> Proving process:

Obviously, it differs with definition of RMS.

In order to be in accord with RMS

=> Action: exchange the priorities of Sa,Sb;

=> the resultant priority assignment is still feasible.

3> Conclusion:

RMPA can be obtained from any Priority ordering by a sequence of pairwise priority re-ordering.


4> Significance:

Advantage:

RMS is proved as the optimum of static scheduling algorithm, more feasible, little overhead;

Disadvantage:

Processor Utilization is not high

When n→∞,

Processor utilization=ln2 ≈70%.


5> Question?

scenario: Priority Inversion

in real-time system, resources are shared by real-time tasks, it may happens that a lower priority task will block the processing of a task with higher priority.

=> deadlock happens!!!

=> RMS cannot provide a proper schedule for the set of task.

Any solution?


6> Solution

Control the time of priority inversion to be limited

Based on requirements, it needs some protocol to ensure that.


4. Processor Utilization

1) The least upper bound to PU in a fixed priority systems.

PU factor:

Ci increases, or Ti decreases,

=> U is improved.

Note: Precondition is all tasks satisfy their deadlines at their Critical _Instant.


U = S (Ci/Ti)T=request periods1/T=frequencyC=run-time


2) Significance the least upper bound of UP factor is

the minimum of the PU factors over all sets of tasks that fully utilize the processor.

For all task sets whose PU factor is below this bound, there exists a fixed priority assignment which is feasible.

For PU factor is above this bound can only be achieved if the of the tasks are suitably related.



2) Significance The least upper bound to be determined is the

infimum of the utilization factors corresponding to the RMPA over all possible Request_Period and run-times for the tasks.

The least upper bound is firstly determined for two tasks, then extended for an arbitrary number of tasks.



3) Theorem 3 For a set of 2 tasks with fixed priority assignment,

the least upper bound to the PU factor is U= 2(2(1/2)-1)

Such as: if the Request_Period, Tb, for the lower Priority task is a multiple of the other task’s Request_Period, Ta.

for U = 1- f(1-f)/(I+f), I=[Tb/Ta], f= {Tb/Ta}

=> when f = 0, PU factor: U=1



4) Theorem 4 For a set of m tasks with fixed priority order, and

the restriction that the ratio between any two Request_Period, Tb/Ta<2,

the least upper bound to the PU factor is:

U = m(2 1/m -1);



5) Theorem 5 For a set of m tasks with fixed priority order,

the least upper bound to PU is U = m(2 1/m -1);

=> to determine the least upper bound of the PU factor, we need only consider task sets in which the ratio between any two Request_Period,Tb/Ta, is less than 2


5. Relaxing the Utilization Bound:

Limitation:

for real-time guaranteed service, the least upper bound can approach ln2 for large task sets.

How to improve the situation?

if f= {Tm/Ti}=0, for i=1,2,…,(m-1).

But, it cannot always be done.



alternative solution:

1. buffer the lower priority task, Sm, and perhaps several of the lower priority tasks.

2. relax their head deadlines.

suppose:

1. the entire task set has a finite period

2. the buffered tasks are executed in some reasonable fashion.



=> Delay_Timem & amount of buffering required

can be computed.

=> Dynamic fashion is a better solution,

with PU factor 100%.



DDSA & Policy of Priority setting4-1

Necessary and sufficient condition4-2

1. DDSA

Deadline Driven Scheduling Algorithm;

it is Dynamic Scheduling Algorithm

called in the paper.

Policy of Priority setting:

Priority is assigned to a task according to the deadline of its current request.


1. Dynamic Scheduling Algorithm

that means,

if the deadline of the task’s current request is the nearest,

=>a task will be assigned the highest priority

if the deadline of the task’s current request is the furthest,

=> a task will be assigned the lowest priority


2. Necessary and sufficient condition for the feasibility of the algorithm.

Theorem 6

When the DDSA is used to schedule a set of tasks on a single processor, there is no processor idle time prior to an overflow.


2. Necessary and sufficient condition for the feasibility of the algorithm.

Theorem 7

For a given set of tasks, the DDSA is feasible if and only if,

(C1/T1) + (C2/T2) +…+ (Cm/Tm) <= 1

Judgment is rest on: if the total demand > the available processor time

=> it is not a feasible scheduling algorithm


Concept5-1

Mathematical results5-2

Theorem & Proof:Processor Utilization


1. Concept

MSA are combinations of RMSA and DDSA

2. Mathematical results:

1)Theorem 8

If a set of tasks are scheduled by the DDSA on a processor whose availability function is sublinear, then there is no processor idle period to an overflow.


2) Theorem 9

A necessary and sufficient condition for the feasibility of the DDSA with respect to a processor with availability function ak(t) is

[t/Tk+1] Ck+1 + [t/Tk+2] Ck+2 +…+ [t/Tm] Cm<=ak(t)

for all t’s which are multiples of Tk+1, or Tk+2,

…, or Tm.


Notes:

ak(t) is a non-decreasing function of t.

ak(t) is sublinear, if for all t and all T,

a(T)<= a(t+T) – a(t)

Significance:

100% utilization is not achievable universally by the MSA.



Advantages6-1

Comparison 6-2

Advantage:

URMSA < UMSA < UDDSA

The least upper bound is considerably less restrictive for the MSA than RMSA.

URMSA is only slightly greater than the worst case of UMSA.

=> MSA is preferred.


Comparison:

Example:

If T1=3, T2=4, T3=5, a1(20)=13,

C1=1, C2=1, C3=2

Here we go:

to prove MSA is prefferred.


Based on the reasoning of Theorem 1,

=> C1+ C2+C3 <= T1

1 + 1+ C3 <=3

=> C3max <= 1

=> URMSA = 1/3+1/4+1/5=78.3%


Based on Theorem 7,

=> C1/T1 + C2/T2 +C3/T3 <= 1

1/3 + 1/4+ C3/5 <=1

=> C3max <= 25/12 ≈ 2.0833

=> UDDSA = 1/3+1/4+2.0833/5

= 1/3+1/4+(25/12)/5 =100%


Based on Theorem 9,

=> if k=1, then [t/T2]C2 + [t/T3]C3 <= a1(20)

[20/4]*1 + [20/5]C3 <= 13

=> C3max = 2

for U = C1/T1 +C2/T2 +C3/T3

=> UMSA = 1/3+1/4+2/5=98.3%


Problems associated with multiprogramming are focused in a hear-real-time environment typified by process control and monitoring, using some assumptions which characterize that application.

Conclusion7

3. Conclusion

for all fixed priority scheduling algorithm:

which assigns priority to tasks in a monotonic relation to their Request_Rate was shown to be optimum among the class of all fixed priority scheduling algorithms.

The least upper bound of PU factor is on the order of 70% for large task sets.

Conclusion7

3. Conclusion

Dynamic Deadline Driven Scheduling Algorithm:

is shown to be globally optimum and capable of achieving 100%

Conclusion7

3. Conclusion

Mixed Scheduling Algorithm:

appears to provide most of the benefits of the Deadline Driven Scheduling Algorithm, and yes may be readily implemented in existing computers.

Conclusion7

scheduling algorithms for multiprogramming in a hard-real-time environments gracia yuen umum

Documents