CS452 - Real-Time Programming - Fall 2009

Lecture 8 - Create( ), Scheduling

Reminder

• Partners and Unix groups

Creating a Task

In creating a task you have to do two things

1. Get and initialize resources needed by the task
   • TD
   • memory
2. Make the task look as if it had just entered the kernel
   • it's ready to execute

Things you need to do

Get an unused TD and memory for its stack

• memory could be associated with TD during initialization
• actually a form of constant time memory allocation
• unless you implement Destroy

Mostly filling in fields in the TD.

1. task id
2. stack pointer
3. SPSR
4. link register
5. parent tid
   • the active task
6. return value
   • dummy
   • different return value for the active task, which goes in its TD
7. state
   • READY
8. install in the ready queues
   • pointers in the TD

Must also create the initial stack

• exactly as if the task had just done a kernel entry
• look carefully at what your kernel exit code will do
• At the end stack pointer must correspond to stack contents
• I initialize the stack pointer to the top of allocated memory
  • my stacks grow down

  then change it as I push stuff onto the stack imitating the context switch code

The Create Function

You also need a int Create( int priority, void (*code) ( ) ) function to call from user tasks.

Although it's no more than a wrapper there are a few problems to solve.

1. Passing arguments
   • On entry the arguments are somewhere, usually r0 & r1
   • You have to put them where the kernel can find them.
   • gcc's function extry code immediately puts them on the stack.
   • In assembly you can find them using the frame pointer.
2. Jumping into the kernel
3. Getting the return value from the kernel and returning it.
   • You find it where the kernel put it
   • gcc's function exit code expects it to be indexed off the frame pointer
     • from where it does into r0

Scheduling

When to schedule

Whenever we leave the kernel. When do we enter the kernel?

1. Tasks run to completion
2. Event-driven pre-emption
   • internal events, like Pass( ), or Send( ), which occur when a task gets to a particular point in its code
   • external events
3. Time-slicing
   • re-schedule only when the slice-timer times out
   • on internal events
   • two problems
     1. slices are too big => bad response
     2. slices are too small => kernel runs too much = bad response

Who to Schedule

1. active task decides = co-processes
2. round robin
   • everybody gets the same chance
   • but usually long running time = unimportant
3. priorities
   1. fixed at compile time
   2. fixed when task is created
   3. re-fixed every time task is scheduled
      • Do you have a good algorithm
4. hybrid
   • round robin queues for each priority
5. determined by type of kernel entry
   • Send wakes Receiver
   • interrupt wakes interrupt destination

What God has Decided

Hybrid

What you decide

1. How many priorities
2. Which task should have which priority

How to implement the queues

• one queue per priority
  • fast insertion, but needs back pointer
  • slow activation, but use a highest priority pointer

one sorted queue

• slow insertion, but can be speeded up

fast activation

Return to:

• Bill Cowan's Fall 2009 CS452 page
• Bill Cowan's CS452 page
• Bill Cowan's teaching page
• Bill Cowan's home page