How to restart a task

Question

How to restart a lower priority task from a higher priority task?

This is a general question about how RTOS in embedded systems work.

I have multiple tasks with different priorities. The lower priority task has certain steps e.g., step1, step2, step3.

The highest priority task handles system malfunctions. If a malfunction occurs then an ISR in the system will cause the higher priority task to immediately run.

My question ... If system malfunction occurs while the lower priority task in middle e.g., step2 and we do not want to run the rest of the steps in the lower priority task, then how do we accomplish it?

My understanding is that when the scheduler is ready to run the lower priority task then it will continue from where it left off prior to system malfunction. So step3 will be executed.

Does embedded RTOS (e.g., Keil RTX or FreeRTOS) provide such a mechanism so that on certain signal from higher priority task/ISR the lower priority task can restart?

I don't recall ever seeing an RTOS function for restarting a running task. But I suppose you could delete and recreate the task if that is really what is appropriate for your application. For example, see FreeRTOS vTaskDelete() and xTaskCreate(). — kkrambo
The low priority task should offer a mechanism to go to step1 in case of an event happens (event which was triggered by the high priority task). — Jose

Clifford Clifford · Accepted Answer · 2019-02-12T12:14:42

The mechanism you are suggesting is unlikely to be supported by an RTOS since it would be non-deterministic in its behaviour. For example such an RTOS mechanism would have no knowledge of resource allocation to initialisation within the task and whether it would be safe to simply "restart", or how to clean-up if it were not.

Moreover the RTOS preempts at the machine instruction level, not between logical functional "steps" - there is no determination of where it is in the process.

Any such mechanism must be built into the task's implementation at the application level not the RTOS level in order that the process is controlled and deterministic. For example you might have a structure such as:

for(;;)
{
    step1() ;
    if( restart() )
    {
        clean_up() ;
        continue ;
    }

    step2() ;
    if( restart() )
    {
        clean_up() ;
        continue ;
    }

    step3() ;
}

Where the malfunction requests a restart, and the request is polled through restart() at specific points in the task where a restart is valid or safe. The clean_up() performs any necessary resource management, and the continue causes a jump to the start of the task loop (in a more complex situation, a goto might be used, but this is already probably a bad idea - don't make it worse!).

Fundamentally the point is you have to code the task to handle the malfunction appropriately and the RTOS cannot "know" what is appropriate.

While there is no generic RTOS mechanism for what you are suggesting, it is possible perhaps to implement a framework to support the required behaviour, but it would require you to write all your tasks to a specific pattern dictated by such a framework - implementing a comprehensive solution that handles resource clean-up in a simple manner however is non-trivial.

QNX Neutrino has a "High Availability Framework" for example that supports process restart and automatic clean-up. It is an example of what can be done, but it is of course specific to that RTOS. If this behaviour is critical to your application, then you need to select your RTOS accordingly rather then rely on "traditional" mechanisms available to any RTOS.

How to restart a task

1 Answers