Assignment 3, COSC 6384
Fall 2008
Task scheduling in real-time systems is to determine an execution order such that all
tasks can meet the corresponding deadlines. To do this, we often need an estimate of the
worst-case execution time (WCET) and then reserve that amount of CPU time
accordingly. An overrun occurs if the real execution time exceeds the estimate WCET.
When it is undetected, subsequent tasks may miss their deadline as a consequence of
overspending CPU time. One solution to the task overrun problem is to lower the priority
of the overrunning task once it consumes the reserved CPU time and only execute it in
the background mode. This requires a measurement of task execution time at run
time.
In real-time systems, a task may be preempted (by high priority tasks) or blocked (due to
unavailable resources locked by low priority tasks). The measurement of execution time
at user application level is difficult, since we cannot predict the instances of preemption
and blocking. On the other hand, it can be done easily at kernel level. As shown in the
following diagram, a task is created, dispatched to run, switched off to waiting or ready
state, and deleted (terminated). The measurement of execution time can be done once we
mark the instances it is dispatched and accumulate the time it has spent when it is
switched off or terminated.
vxWorks allows user tasks to add callback functions (hooks) to kernel at the instances of
task creation, task deletion, and context switching. When a hook is called, the pointer to
the task’s TCB is passed as a parameter. Thus, we can access TCB and use the spare
space in TCB to record additional task information.
What you will do in the assignment:
