This section contains quality attributes of the QP Framework (a.k.a., Non-Functional Requirements).

Compliance with Standards

Software Quality Attributes

Performance Requirements

Portability Requirements

Ease of Development Requirements

REQ-QP-09_01

REQ-QP-09_01
All services provided by QP must not use the standard heap
Background The QP Framework must not force Applications to use potentially unsafe and indeterministic memory allocation policies, like the standard heap. In other words, the QP Framework should internally use only static memory with worst-case memory consumption known at compile time.

REQ-QP-09_02

REQ-QP-09_02
All State Machine Implementation Strategies provided by QP Framework shall be "debuggable"
Background "Debuggable" state machine implementation means that it should always be possible to set a single debugger breakpoint in the code to stop upon the execution of a given state machine element, such as a state transition or entry to a given state, exit from a given state, a given guard condition, etc. An example of a non-"debuggable" implementation would be one in which a given transition or entry to a state would be represented more than once in the code. A single breakpoint would not necessarily be sufficient to guarantee that the breakpoint is reached when that element is executed. Non-"debuggable" state machine implementations are often the result of "flattening" the hierarchical state machine to the non-hierarchical representation, which causes repetitions of transitions.
Rationale "Debuggability" is essential for effective development and maintenance of the state machine code.

REQ-QP-09_03

All services provided by QP shall use limited and known amount of call stack

Background
The services need to consume a limited and known amount of call stack.

Note: The actions associated with various state machine elements, also consume the call stack on top of what QP services are already used, but they are defined in the Application and their execution characteristics are out of control of the QP Framework.

Rationale
Overflowing the call stack is one of the highest risks in software systems and safety standards put great emphasis on preventing stack overflow. This is especially exacerbated in a system running traditional Real-Time Operating Systems, where each thread requires its private call stack, so stack overflow must be prevented in each case. In such environments, low and deterministic stack consumption is of paramount importance and is required to comply with safety standards.

Preemptive Dual-Mode Kernel