QP/C  5.9.5
QV

Cooperative Kernel. More...

Files

file  qpc.h
 QP/C public interface including backwards-compatibility layer.
 
file  qv.h
 QV/C (cooperative "Vanilla" kernel) platform-independent public interface.
 
file  qv.c
 Cooperative QV kernel, definition of QP::QV_readySet_ and implementation of kernel-specific functions.
 
file  qf_port.h
 QF/C port example for QV, generic C compiler.
 
file  qv_port.h
 QV/C port example for a generic C compiler.
 

Detailed Description

Cooperative Kernel.

Description
QV is a simple cooperative kernel (previously called "Vanilla" kernel). This kernel executes active objects one at a time, with priority-based scheduling performed before processing of each event. Due to naturally short duration of event processing in state machines, the simple QV kernel is often adequate for many real-time systems.

QV Overview

The QV scheduler is engaged after every RTC step of any term_active object to choose the next active object to execute. The QV scheduler always chooses the highest-priority active object that has any events in its event queue. The QV scheduler then extracts the next event from this queue and dispatches it to the state machine associated with the active object. The state machine runs to completion, after which the QV scheduler runs and the cycle repeats.

Please note that because the state machines always return to the QV scheduler after each RTC step, a single stack can be used to process all state machines (memory-friendly architecture).

The QV scheduler can also very easily detect when all event queues are empty, at which point it can call the idle callback to let the application put the CPU and peripherals to a low-power sleep mode (power-friendly architecture).

Given the simplicity, portability, and low-resource consumption, the QV scheduler is very attractive. It allows you to partition the problem into active objects and execute these active objects orderly. The task-level response of this scheduler is the longest RTC step in the whole system, but because event-driven active objects don’t block, the RTC steps tend to be very short (typically just a few microseconds). Also, often you can break up longer RTC steps into shorter pieces, by posting an event to self and returning (“Reminder” state pattern). The self-posted event then triggers the continuation of longer processing.