PXROS time slicing implementation

If the time slicing parameter is set to zero, which is also the default value, the time slicing is not used. In such a scenario, when two tasks share the same priority, only one will be actively executing while the other one will remain dormant. The other task will not be given an opportunity to run unless the active task encounters a situation where it needs to wait for a specific event or condition.

When the time slicing value is set to a non-zero value, it defines the duration, measured in ticks, for which a task remains in an active state before the kernel moves it to the end of the ready queue associated with its corresponding priority level. In simpler terms, it sets the time limit for each task’s execution before it temporarily yields control to other tasks.

Suppose there are multiple tasks with the same priority level. In such a scenario, the kernel employs a round-robin scheduling scheme to ensure fair execution. The tasks are arranged in a ready queue, waiting for their turn to be executed. When a task’s time slice elapses, meaning it has been actively running for the specified number of ticks, the kernel places that task at the end of the ready queue.

The kernel scans the ready queue and checks if there are other tasks at the same priority level that are ready and not suspended. If it finds another task, it schedules it for execution, allowing it to run for its own time slice duration. This process continues, with each task receiving its limited amount of CPU time according to their respective time slicing values.

It’s important to note that the time slicing value can vary from task to task. This flexibility allows different tasks to have distinct time slice durations, enabling fine-grained control over their execution patterns. Some tasks may require longer periods of uninterrupted execution while the other ones may accept more frequent context switching.

Time slicing can be effectively utilized in scenarios where multiple low-priority tasks need to run concurrently within a while(1) loop, without invoking any blocking functions. Consider a situation where certain tasks involve lengthy computations or continuous polling operations. By assigning these tasks the same priority level and configuring appropriate time slice values, it becomes possible to allocate CPU time to each task in a fair and controlled manner.

In such cases, if all higher priority tasks are in a waiting state, the lower priority tasks with non-zero time slices will be eligible for execution. The kernel will schedule these tasks based on their respective time slice allocations, expressed in ticks. As a result, the lower priority tasks will run in a round-robin fashion, ensuring that each task receives its fair share of CPU time according to its time slice portion.

Below is a simple diagram illustrating the time slicing of two tasks with identical priority (Task 2 and Task 3). These tasks are intermittently interrupted by another task (Task 1) with a higher priority where time slicing is disabled.