Getting Started with QNX Neutrino - QNX Software Systems

© 2009, QNX Software Systems GmbH & Co. KG. Scheduling and the real world
Rescheduling — hardware interrupts
Rescheduling due to a hardware interrupt occurs in two cases:
• timers
• other hardware
Rescheduling — kernel calls
The realtime clock generates periodic interrupts for the kernel, causing time-based
rescheduling.
For example, if you issue a sleep (10); call, a number of realtime clock interrupts
will occur; the kernel increments the time-of-day clock at each interrupt. When the
time-of-day clock indicates that 10 seconds have elapsed, the kernel reschedules your
thread as READY.
(This is discussed in more detail in the Clocks, Timers, and Getting a Kick Every So
Often chapter.)
Other threads might wait for hardware interrupts from peripherals, such as the serial
port, a hard disk, or an audio card. In this case, they are blocked in the kernel waiting
for a hardware interrupt; the thread will be rescheduled by the kernel only after that
“event” is generated.
If the rescheduling is caused by a thread issuing a kernel call, the rescheduling is done
immediately and can be considered asynchronous to the timer and other interrupts.
For example, above we called sleep(10);. This C library function is eventually
translated into a kernel call. At that point, the kernel made a rescheduling decision to
take your thread off of the READY queue for that priority, and then schedule another
thread that was READY.
There are many kernel calls that cause a process to be rescheduled. Most of them are
fairly obvious. Here are a few:
• timer functions (e.g., sleep())
Rescheduling — exceptions
• messaging functions (e.g., MsgSendv())
• thread primitives, (e.g., pthread_cancel(), pthread_join())
The final cause of rescheduling, a CPU fault, is an exception, somewhere between a
hardware interrupt and a kernel call. It operates asynchronously to the kernel (like an
interrupt) but operates synchronously with the user code that caused it (like a kernel
call — for example, a divide-by-zero exception). The same discussion as above (for
hardware interrupts and kernel calls) applies to faults.
April 30, 2009 Chapter 1 • Processes and Threads 77