IPC@CHIP Documentation - SC12 @CHIP-RTOS V1.10

Time-Slicing
For the tasks created within DOS programs by the user, a time-slicing feature is available. This feature is
enabled for a specific task by specifying a non-zero number of milliseconds in the time_slice member of the
TaskDefBlock structure passed to the RTX_Task_Create() or RTX_Task_Create_Without_Run() functions.
A time-sliced task will be permitted to execute for time_slice milliseconds (RTI ticks) after which time it will
be cycled to the end of the list of tasks at this task's user priority. (The task is not charged for ticks during
which it was blocked, suspended or active-pending preempted by some higher priority task.) In the special
case where it is the only active task at that user priority, it would then on time-out immediately be given
another time_slice milliseconds execution time budget and allowed to continue execution. Otherwise one of
the other active tasks pending execution at this same user priority will begin execution and the previously
executing task whose time-slice expired will be cycled to the end of the priority queue in a round-robin
fashion. Note that the next task to execute may or may not be configured for time_slice operation.
The time-slice operation would apply primarily to fully independent tasks which do not pass any data
between each other. Time-slicing can introduce chaos into a program which could execute more orderly
using explicit yields (e.g. RTX_Sleep_Time API). The extra task switching due to time-slice operation can
cause critical sections to appear where they otherwise would not if the task was permitted to execute up to
where the program yields voluntarily.
There may be times where time-slicing is the graceful design solution, but reliance on this technique raises
the suspicion that the software design was not thought out thoroughly. Also keep in mind that any task with
lower user priority than the time-sliced tasks will never be executed so long as any of the time-sliced tasks
are active. During execution of a time-sliced task, there is a very slight additional load placed on the
system's 1000 Hz RTI.
Periodic Tasks
Periodic tasks can be created in either of two ways, depending on how accurate the execution period is
required to be for the respective application.
Roughly Periodic
The simplest form for a periodic task uses a RTX_Sleep_Time call within a loop as shown below in
Figure 1. The period of this loop will not be exact, but would be close enough for many applications.
#define SLEEP_10HZ (90) // Assuming 10 ms CPU load per 100 ms
void huge Task_Roughly_10Hz(void)
{
while (1)
{
Activity_10Hz() ; // Get here about each 100 ms
RTX_Sleep_Time(SLEEP_10HZ) ;
}
}
Page 224 / 400