Task Services

Task State

A microkernel task has an associated state that determines whether or not it can be scheduled for execution. The state records all factors that can prevent the task from executing, such as:

• the task has not been started
• the task is waiting for it needs (e.g. a semaphore, a timeout, ...)
• the task has been suspended
• the task has terminated

A task whose state has no factors that prevent its execution is said to be executable.

Task Priorities

A microkernel application can be configured to support any number of task priority levels using the NUM_TASK_PRIORITIES configuration option.

An application task can have any priority from 0 (highest priority) down to NUM_TASK_PRIORITIES-2. The lowest priority level, NUM_TASK_PRIORITIES-1, is reserved for the microkernel’s idle task.

A task’s original priority can be altered up or down after the task has been started.

Scheduling Algorithm

The microkernel’s scheduler always selects the highest priority executable task to be the current task. If multiple executable tasks of that priority are available the scheduler chooses the one that has been waiting longest.

Once a task becomes the current task it remains scheduled for execution by the microkernel until one of the following occurs:

• The task is supplanted by a higher priority task that becomes ready to execute.
• The task is supplanted by an equal priority task that is ready to execute, either because the current task explicitly calls task_yield() or because the kernel implicitly calls task_yield() because the scheduler’s time slice has expired.
• The task is supplanted by an equal or lower priority task that is ready to execute, because the current task calls a kernel API that blocks its own execution. (For example, the task attempts to take a semaphore that is unavailable.)
• The task terminates itself by returning from its entry point function.
• The task aborts itself by performing an operation that causes a fatal error, or by calling task_abort().

Time Slicing

The microkernel’s scheduler supports an optional time slicing capability that prevents a task from monopolizing the CPU when other tasks of the same priority are ready to execute.

The scheduler divides time into a series of time slices, whose size is measured in system clock ticks. The time slice size is specified by the TIMESLICE_SIZE configuration option, but this size can also be changed dynamically while the application is running.

At the end of every time slice the scheduler implicitly invokes task_yield() on behalf of the current task, thereby giving all other tasks of that priority the opportunity to execute before the current task can once again be scheduled. If one or more equal priority tasks are ready to execute, the current task is preempted to allow those tasks to execute. If no equal priority tasks are ready to execute, the current task remains the current task, and continues to execute.

Tasks having a priority higher than that specified by the TIMESLICE_PRIORITY configuration option are exempt from time slicing, and are never preempted by a task of equal priority. This capability allows an application to use time slicing only for lower priority tasks that are less time-sensitive.

Task Suspension

The microkernel allows a task to be suspended, which prevents the task from executing for an indefinite period of time. The task_suspend() API allows an application task to suspend any other task, including itself. Suspending a task that is already suspended has no additional effect.

Once suspended, a task cannot be scheduled until another task calls task_resume() to remove the suspension.

Public Task

Define the task in the application’s MDEF using the following syntax:

TASK name priority entry_point stack_size groups

The task groups are specified using a comma-separated list of task group names enclosed in square brackets, with no embedded spaces. If the task does not belong to any task group specify an empty list; i.e. [].

For example, the file projName.mdef defines a system comprised of six tasks as follows:

% TASK NAME           PRIO  ENTRY          STACK   GROUPS
% ===================================================================
  TASK MAIN_TASK        6   keypad_main     1024   [KEYPAD_TASKS,EXE]
  TASK PROBE_TASK       2   probe_main       400   []
  TASK SCREEN1_TASK     8   screen_1_main   4096   [VIDEO_TASKS]
  TASK SCREEN2_TASK     8   screen_2_main   4096   [VIDEO_TASKS]
  TASK SPEAKER1_TASK   10   speaker_1_main  1024   [AUDIO_TASKS]
  TASK SPEAKER2_TASK   10   speaker_2_main  1024   [AUDIO_TASKS]

A public task can be referenced by name from any source file that includes the file zephyr.h.

Private Task

Define the task in a source file using the following syntax:

DEFINE_TASK(PRIV_TASK, priority, entry, stack_size, groups);

The task groups are specified using a list of task group names separated by |; i.e. the logical OR operator. If the task does not belong to any task group specify NULL.

For example, the following code can be used to define a private task named PRIV_TASK.

DEFINE_TASK(PRIV_TASK, 10, priv_task_main, 800, EXE);

To utilize this task from a different source file use the following syntax:

extern const ktask_t PRIV_TASK;

Public Task Group

Define the task group in the application’s .MDEF file using the following syntax:

TASKGROUP name

For example, the file projName.mdef defines three new task groups as follows:

% TASKGROUP   NAME
% ========================
  TASKGROUP   VIDEO_TASKS
  TASKGROUP   AUDIO_TASKS
  TASKGROUP   KEYPAD_TASKS

A public task group can be referenced by name from any source file that includes the file zephyr.h.