welcome l.
Skip this Video
Loading SlideShow in 5 Seconds..
Welcome! PowerPoint Presentation
Download Presentation

Loading in 2 Seconds...

play fullscreen
1 / 75

Welcome! - PowerPoint PPT Presentation

  • Uploaded on

Welcome!. PhD Dissertation Defense. PhD Candidate: Wenming Li Advisor: Dr. Krishna M. Kavi Committee: Dr. Krishna M. Kavi Dr. Robert Akl Dr. Phil Sweany. Group-EDF - A New Approach And An Efficient Non-Preemptive Algorithm for Soft Real-Time Systems. Contributions.

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about 'Welcome!' - allyson

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
phd dissertation defense
PhD Dissertation Defense

PhD Candidate: Wenming Li

Advisor: Dr. Krishna M. Kavi


Dr. Krishna M. Kavi

Dr. Robert Akl

Dr. Phil Sweany

  • A new approach for soft real-time systems.
  • A new scheduling algorithm for soft real-time systems and soft Real-Time Operating System (RTOS).
contributions cont d
Contributions (Cont’d)
  • Our research work is a new approach for soft real-time systems.

- First proposed the strategy of the dynamic grouping of tasks with deadlines.

- First proposed a two-level scheduling scenario for real-time tasks.

contributions cont d6
Contributions (Cont’d)
  • Group-EDF is a new scheduling algorithm for soft RTOS and real-time systems.

- First proposed to use Earliest Deadline First (EDF) for dynamic groups and Shortest Job First (SJF) within a group.

  • Soft real-time systems and soft RTOS.
  • Non-preemptive scheduling.
  • Real-time periodic, aperiodic, or sporadic tasks.
the taxonomy of real time scheduling
The Taxonomy of Real-time Scheduling

Our EDF/gEDF algorithm is applicable to the shaded region

hard real time systems
Hard Real-Time Systems
  • Every resource management system must work in the correct order to meet time constraints. No deadline miss is allowed.
  • Disadvantage

- Low utilization

soft real time systems
Soft Real-Time Systems
  • It is similar to hard real-time systems. But it is not necessary that every time constraint be met. Some deadline miss is tolerated.
  • Advantage

- High utilization

non preemptive scheduling
Non-Preemptive Scheduling
  • Why non-preemptive?

- non-preemptive scheduling is more efficient than preemptive scheduling since preemption incurs context switching overhead which can be significant in fine-grained multithreading systems.

basic real time scheduling
Basic Real-Time Scheduling
  • First Come First Served (FCFS)
  • Round Robin (RR)
  • Shortest Job First (SJF)
first come first served fcfs
First Come First Served (FCFS)
  • Simple “first in first out” queue
  • Long average waiting time
  • Negative for I/O bound processes
  • Nonpreemptive
round robin rr
Round Robin (RR)
  • FCFS + preemption with time quantum
  • Performance (average waiting time) is proportional to the size of the time quantum.
shortest job first sjf
Shortest Job First (SJF)
  • Optimal with respect to average waiting time.
  • Requires profiling of the execution times of tasks.
static priority scheduling rate monotonic rm
Static Priority Scheduling – Rate-Monotonic (RM)
  • The shorter the period of a task, the higher is its priority (relative deadline = period).
  • A set of n independent, periodic jobs can be scheduled by the rate monotonic policy if

e1/P1 + e2/P2 + … + en/Pnn (21/n - 1)

- The upper bound on utilization is ln2 = 0.69 as n approaches infinity.

static priority scheduling deadline monotonic dm
Static Priority Scheduling – Deadline-Monotonic (DM)
  • The shorter the relative deadline of a task, the higher is its priority.
  • Suitable when relative deadline period
  • For arbitrary relative deadlines, DM outperforms RM in terms of utilization.
dynamic priority scheduling earliest deadline first edf
Dynamic Priority Scheduling – Earliest Deadline First (EDF)
  • The first and the most effectively widely used dynamic priority-driven scheduling algorithm.
  • Effective for both preemptive and non-preemptive scheduling periodic, aperiodic, and sporadic tasks.
preemptive edf
Preemptive EDF
  • For a set of preemptive periodic, aperiodic, and sporadic tasks, EDF is optimal in the sense that EDF will find a schedule if a schedule is possible for other algorithms.

- Approach 100% utilization for periodic tasks

non preemptive edf
Non-Preemptive EDF
  • Optimal for sporadic non-preemptive tasks.
  • Scheduling periodic and aperiodic non-preemptive tasks is NP-hard.

- Approach near optimal for non-preemptive scheduling on a uniprocessor system.

theory of edf
Theory of EDF
  • Minimize maximum lateness Lmax = max {Li | i = 1, …, n} = max {Ci- di | i = 1, …, n}
  • The problem: 1 | nonpmtn | Lmax
  • Any sequence of jobs in nondecreasing order of due dates di, results in an optimal schedule.
  • The scheduling problem {1 | nonpmtn, ri | Lmax}is NP-hard.
  • Let Lmax = max {Ci- di | i = 1, …, n} = 0, that is, all deadlines of tasks must be met.
posix 1003 1b
POSIX 1003.1b
  • Portable Operating System Interface (POSIX) 1003.1b, the IEEE Computer Society’s Portable Application Standards Committee (PASC)




related work
Related Work
  • Domino Effect of EDF

- Overload

  • Overload Detection And Control

- Best-effort by value-density V/C

- Admission control

- Disadvantage:

Needing accurate utilization computing

Switching between two scheduling schemes

Using Worst Case Execution Time (WCET)

related work25
Related Work
  • SCAN-EDF for disk scheduling

- Use SJF to break deadline ties

  • Quantized deadlines (from CMU)

- Static deadline windows

our real time model
Our Real-time Model
  • A task (job) in a real-time system or a thread in multithreading processing i is defined as:

i = (ri, ei, Di, Pi)

overview of gedf
Overview of gEDF
  • Divide real-time jobs into groups by their deadlines, dynamically.
  • Groups are based on EDF but tasks within a group may be scheduled based on a different scheme - SJF, Value, Priority, etc.
  • gEDF is used both in underload and overload.
overview of gedf cont d
Overview of gEDF (Cont’d)
  • We use SJF to enhance EDF, but it is extensible to other scheduling schemes.
  • gEDF is suitable for non-preemptive soft-real-time systems.
  • The criteria of selecting suitable grouping policy is flexible
      • Static deadline windows
      • Dynamic windows as jobs arrive
overview of gedf cont d29
Overview of gEDF (Cont’d)
  • A group in the gEDF algorithm depends on a group range parameter Gr.
  • A job j belongs to the same group as job i if didj (di + Gr*(di – t)), where t is the current time, 1 i, jN. We group jobs with deadlines that are very close to each other.

- The jobs with very close deadlines are in a group (but not necessary if at the boundary of groups)

the gedf algorithm
The gEDF Algorithm
  • We assume a uniprocessor system. QgEDF is a queue for gEDF scheduling. The current time is represented by t. |QgEDF| represents the length of the queue QgEDF.  = (r, e, D, P) is the job at the head of the queue.

- gEDF Group = {k | k QgEDF, dk – d1D1* Gr, 1 km, where m |QgEDF|}, and D1 is the deadline of the first job in a group

the gedf algorithm cont d
The gEDF Algorithm (Cont’d)
  • Function Enqueue (QgEDF, )

if ( ’s deadline d > t ) then

insert job  into QgEDF by Earliest

Deadline First, i.e. di di+1di+2,

where i, i+1,i+2 QgEDF, 1 i |QgEDF| - 2;


- Enqueue is invoked on job arrivals.

the gedf algorithm cont d32
The gEDF Algorithm (Cont’d)
  • Function Dequeue (QgEDF)

if QgEDFthen

find a job min with

emin = min {ek | k QgEDF,

dk – d1Gr*D1, 1 km, where m |QgEDF|};

run it and delete min from QgEDF;


- Dequeue is called when the processor becomes idle.

the experiment
The Experiment
  • Used MATLAB provided tools to generate tasks.

- In each experiment generated N tasks.

- The jobs are scheduling using EDF & gEDF.

- The experiment is truncated at a predetermined time T.

Success rate is computed based on m out of N jobs completed.

the experiment cont d
The Experiment (Cont’d)
  • Varied

- Load (or utilization)

- Execution time

- Deadline (tight deadlines & loose deadlines)

- Group range

- Deadline tolerance (hard vs. soft real-time)

the experiment cont d35
The Experiment (Cont’d)
  • For each set of parameters, the experiment is repeated 100 times and the results shown are the averages from the 100 experiments.
success ratio gedf vs edf summary of the three previous figures40
Success Ratio: gEDF vs. EDFSummary of the three previous figures
  • The gEDF algorithm obtains higher success ratio under higher system loads.
  • Suitable for soft real-time systems.
Effect of Deadline Laxity on Success RatioTight Deadline D = 1 (Deadline = Execution Time)and hard real-time
Effect of Deadline Laxity on Success RatioTight Deadline D = 1 (Deadline = Execution Time)and softer real-time
effect of deadline laxity on success ratio loose deadline d 5 deadline 5 execution time
Effect of Deadline Laxity on Success RatioLoose Deadline D = 5 (Deadline = 5*Execution Time)
effect of deadline laxity on success ratio loose deadline d 5 deadline 5 execution time45
Effect of Deadline Laxity on Success RatioLoose Deadline D = 5 (Deadline = 5*Execution Time)
Effect of Deadline on Success RatioSuccess Ratio of EDF when D = 1, 2, 5, 10, and 15(i.e. Deadline = D*Execution Time)
Effect of Deadline onSuccess RatioSuccess Ratio of gEDF when D = 1, 2, 5, 10, and 15(i.e. Deadline = D*Execution Time)
effect of deadline on success ratio
Effect of Deadline onSuccess Ratio
  • The gEDF algorithm has higher performance (i.e. success ratio) than EDF with greater deadline laxity and greater deadline tolerances.
effect of group range gr
Effect of Group Range (Gr)
  • Within our experimental range, the size of the group does not seem to show a great variance.
  • Intuitively

- very large range means gEDF = SJF

- Very short range means gEDF = EDF

  • Optimal window depends on execution times of jobs, deadline tightness, deadline tolerance.
response time gedf vs edf
Response Time: gEDF vs. EDF
  • The gEDF algorithm can yield better (=faster) response times than EDF.
  • Both in underloaded and overloaded situations.
  • Deadline tolerance Tr has greater impact on gEDF than on EDF.
the effect of deadline on response time
The Effect of Deadline onResponse Time
  • When expected value of deadlines D is sufficiently large (>2), gEDF results in faster response times than EDF does.
the gedf implementation in the linux kernel
The gEDF Implementation in the Linux Kernel
  • Keep the original functions for non-real-time applications.
  • Modify structure task_struct and add a new specific runqueue for EDF/gEDF.
  • Add the system call (extension to POSIX)


the gedf implementation in the linux kernel cont d
The gEDF Implementation in the Linux Kernel (Cont’d)
  • Add a new structure

struct edf_param {

unsigned long policy;

unsigned long period;

unsigned long length;


the gedf implementation in the linux kernel cont d62
The gEDF Implementationin the Linux Kernel (Cont’d)
  • Dequeue_edf_task()
  • Enqueue_edf_task() (for EDF & gEDF)
  • Schedule() (include the gEDF algorithm)

- Every one jiffy (1ms), entering the kernel to run schedule function (user process can also yield to other process)

- Complexity O(n) (If using heap, O(log(n)). ref. Ingo Molnar O(1))

testing results cont d gedf s success ratio edf s success ratio
Testing Results (Cont’d)gEDF’s Success Ratio/EDF’s Success Ratio

Y - axis: Load

X - axis: gEDF’s Success Ratio / EDF’s Success Ratio

  • gEDF performs as well as or better than EDF and adaptive algorithms such as Best-Effort and Guarantee schemes.
    • In underloaded, gEDF performs as well as EDF in terms of success ratio; gEDF shows higher success rates than EDF when dealing with soft real-time tasks.
    • In underloaded, gEDF performs much better than EDF in terms of response time.
conclusions cont d
Conclusions (Cont’d)
  • In underloaded, gEDF obtains overall better performance than adaptive algorithms in terms of success ratio and response time.
  • In overloaded, gEDF consistently outperforms EDF both in success ratio and response time.
  • In overloaded, gEDF obtains overall better performance than adaptive algorithms in terms of success ratio and response time.
conclusions cont d summary


Success Ratio

Response Time





Group-EDF vs. EDF





Group –EDF vs. Adaptive













Conclusions (Cont’d)Summary

=: at least as good as>=:better or as good as

>:better>>:much better

future work
Future Work
  • Explore the applicability of gEDF algorithm for Scheduled Dataflow (SDF) Architecture.
  • Explore if gEDF can be used to obtain acceptable (and near optimal) results for multiprocessor systems with soft real-time tasks.
  • Exploring different scheduling scheme applied within each gEDF.
gedf for sdf
gEDF for SDF

SU: Scheduling Unit

EP: Execution Processor SP: Synchronization Processor

PLC: Preload PSC: Poststore EXC: Execution

gedf for multiprocessor
gEDF for Multiprocessor
  • EDF is not optimal for multiprocessor real-time systems.
  • The EDF scheme can be used to schedule dynamic groups on multiprocessors.
  • An optimal or near optimal algorithm may be adopted to schedule jobs distributed on different processors within each dynamic group.
gedf for multiprocessor cont d
gEDF for Multiprocessor (Cont’d)
  • Advantage for using gEDF

- Not limited to SJF

- Possible higher success ratios in underloaded and overloaded situations

scheduling within a group
Scheduling within A Group
  • Exploring different scheduling scheme applied within each gEDF.

- A promising research of applying the gEDF scenario.

  • Reduce overall power consumption.

- Explore a scheduling scheme that minimizes the power consumed by tasks in a group.