Context Viewpoint

Technology ViewpointResource Viewpoint

The Context Viewpoint provides a "black box" perspective on the architecture subject (QP/C Framework in this case) in the surrounding context (QP/C Application and underlying Operating System). The views within this viewpoint identify the stratification of services (layers) and the interfaces between the layers. The Context Viewpoint frames the following concerns:

• context of the architecture subject
• functional decomposition of the system into layers
• interfaces between the layers

The model kind used to illustrate the Context Viewpoint is the UML package diagram Figure SAS-CTXT (static view). It shows the QP/C Framework in the context of other software elements. The architecture is layered with clearly defined interfaces. As required in a truly layered architecture, the dependencies between layers point in one direction only (from higher-level to lower-level layers).

Figure SAS-CTXT: Context of use with layers and QP/C Framework interfaces.

Remarks

In compliance with the UML conventions, the diagrams shown in this section intentionally omit many elements of QP/C Framework or QP/C Applications. The presented views contain only selected elements necessary to explain the high-level structure, but without cluttering the diagrams with irrelevant details.

Note

QP/C Framework classes, their responsibilities, and relationships are described in the Structural View in Software Design Specification.

Layer View

The Layers View explains the QP/C Framework context in terms of distinct layers and their relationships. The objectives of the Layer View are:

• simplification of the interactions inside the system because a software layer can only interact with the layer immediately below.
• promote modularity by encapsulating functionalities within layers. This makes it easier to manage, test, and update individual parts of the system without affecting others.
• enhance scalability by allowing layers to be scaled independently.
• encourage reusability of components within and across projects. For example well-defined QP/C Application layer can be reused in different contexts (e.g., with different operating system or different target hardware), saving development time and effort.
• improve maintainability by isolating changes to specific layers. This reduces the risk of unintended side effects when modifying the system.
• facilitate interoperability by allowing layers to interact only through the well defined interfaces (see Interface View).
• provide flexibility to allow layers to be modified or replaced without impacting the entire system.
• enhance security by isolating sensitive operations within specific layers. This limits the exposure of critical functionalities and data.

SAS_QP_APP

SAS_QP_APP : QP/C Application layer

Description QP/C Application layer (Figure SAS-CTXT [0]) consists of specific Active Object classes and Event classes. The QP/C Application classes inherit and specialize the base classes from QP/C Framework. QP/C Application also uses services provided by the QP/C Framework API. Note The specific classes inside the QP/C Application layer, such as ActiveObjA or EventA, are derived from the QP/C Framework base classes, which are described in the Structural View in Software Design Specification.

SAS_QP_FRM

SAS_QP_FRM : QP/C Framework layer
Description QP/C Framework layer (Figure SAS-CTXT [1]) provides the base classes to be specialized by the QP/C Application. QP/C Framework also provides the runtime environment to execute QP/C Application. Finally QP/C Framework provides the QP/C Framework API, which are services that the specific Active Objects can call directly without subclassing and specializing the base classes. Note The QP/C Framework base classes, such as QActive and QEvt are described in the Structural View in Software Design Specification.
Backward Traceability SRS_QP_NF_03 : QP/C Framework shall be modular. SRS_QP_NF_04 : QP/C Framework shall be layered.
Forward Traceability SDS_QP_QEP : QEP Event Processor QEvt : Event class QEvt::sig : Signal of the event (see Event Signal) QEvt::refCtr_ : Event reference counter. QEvt::evtTag_ : Event "tag" contains pool-ID plus the Duplicate Inverted Storage of the QEvt::refCtr_ QEvt::QEvt_init() : Event without parameters initialization QAsm : Abstract State Machine class (state machine interface) QAsm::vptr : Virtual pointer inherited by all QAsm subclasses (see also Object Orientation) QAsm::temp : Temporary storage for target/act-table etc. QAsm::QAsm_ctor() : Constructor of the QAsm base class QHsm : Hierarchical State Machine class (QHsm-style state machine implementation strategy) QHsm::QHsm_ctor() : Constructor of the QHsm base class QHsm::QHsm_init_() : Implementation of the top-most initial transition in QHsm QHsm::QHsm_dispatch_() : Implementation of dispatching events to a QHsm QHsm::QHsm_isIn_() : Check if a given state is part of the current active state configuration QHsm::QHsm_state() : Obtain the current active state from a HSM (read only) QHsm::QHsm_childState() : Obtain the current active child state of a given parent in QHsm QActive : Active object class (based on the QHsm implementation strategy) QActive::eQueue : Port-dependent event-queue type (often QEQueue) ... QActive::thread : Port-dependent representation of the thread of the active object ... QActive::prio : QF-priority [1..QF_MAX_ACTIVE] of this AO ... QActive::pthre : Preemption-threshold [1..QF_MAX_ACTIVE] of this AO ... QActive::QActive_ctor() : QActive constructor (abstract base class) ... QActive::QActive_start() : Starts execution of an active object and registers the object with the framework ... QActive::QActive_stop() : Stops execution of an active object and removes it from the framework's supervision ... QActive::QActive_post_() : Posts an event e directly to the event queue of the active object using the First-In-First-Out (FIFO) policy ... QActive::QActive_postLIFO_() : Posts an event e directly to the event queue of the active object using the Last-In-First-Out (LIFO) policy ... QActive::QActive_get_() : Get an event from the event queue of an active object ... QActive::QActive_subscribe() : Subscribes for delivery of signal sig to the active object ... QActive::QActive_unsubscribe() : Unsubscribes from the delivery of signal sig to the active object ... QActive::QActive_unsubscribeAll() : Unsubscribes from the delivery of all signals to the active object ... QActive::QActive_psInit() : Publish event to all subscribers of a given signal e->sig ... QActive::QActive_publish_() : Publish event to all subscribers of a given signal e->sig ... QActive::QActive_defer() : Defer an event to a given separate event queue ... QActive::QActive_evtLoop_() : Event loop thread routine for executing an active object act (defined some in QP ports) ... QActive::QActive_register_() : Register this active object to be managed by the framework ... QActive::QActive_unregister_() : Un-register the active object from the framework ... QActive::QActive_subscrList_ : Static (one per-class) pointer to all subscriber AOs for a given event signal ... QACTIVE_POST : Invoke the direct event posting facility QActive_post_() ... QACTIVE_POST_X : Invoke the direct event posting facility QActive_post_() without delivery guarantee ... QACTIVE_POST_LIFO : Post an event to an active object using the Last-In-First-Out (LIFO) policy ... QACTIVE_PUBLISH : Publish an event to all subscriber Active Objects ... QMsm : Hierarchical State Machine class (QMsm-style state machine implementation strategy) QMsm::QMsm_init_() : Implementation of the top-most initial transition in QMsm QMsm::QMsm_dispatch_() : Implementation of dispatching events to a QMsm QMsm::QMsm_isIn_() : Tests if a given state is part of the current active state configuration QMsm::QMsm_getStateHandler_() : Implementation of getting the state handler in a QMsm subclass QMsm::QMsm_stateObj() : Obtain the current state from a MSM (read only) QMsm::QMsm_childStateObj() : Obtain the current active child state of a given parent in QMsm QMsm::QMsm_ctor() : Constructor of QMsm QMsm::QMsm_execTatbl_() : Execute transition-action table QMsm::QMsm_exitToTranSource_() : Exit the current state up to the explicit transition source QMsm::QMsm_enterHistory_() : Enter history of a composite state QMActive : Active object class (based on QMsm implementation strategy) QMActive::QMActive_ctor() : Constructor of QMActive class ... SDS_QP_QF : QF Active Object Framework QPSet : Set of Active Objects of up to QF_MAX_ACTIVE elements QSubscrList : Subscriber List (for publish-subscribe) QTicker : "Ticker" Active Object class QTicker::QTicker_ctor() : Constructor of the QTicker Active Object class QTicker::QTicker_trig_() : Asynchronously trigger the QTicker active object to perform tick processing QTICKER_TRIG : Asynchronously trigger the QTicker AO to perform tick processing QF::QF_init() : QF initialization QF::QF_stop() : Invoked by the application layer to stop the QF framework and return control to the OS/Kernel (used in some QF ports) QF::QF_run() : Transfers control to QF to run the application QF::QF_getQueueMin() : This function returns the minimum of free entries of the given event queue QF::QF_onStartup() : Startup QF callback QF::QF_onCleanup() : Cleanup QF callback QF::QF_poolInit() : Event pool initialization for dynamic allocation of events QF::QF_getPoolMin() : Obtain the minimum of free entries of the given event pool QF::QF_newX_() : Internal QF implementation of creating new mutable (dynamic) event QF::QF_gc() : Recycle a mutable (mutable) event QF::QF_newRef_() : Internal QF implementation of creating new event reference QF::QF_deleteRef_() : Internal QF implementation of deleting event reference QF::QF_onContextSw() : QF context switch callback used in built-in kernels (QV/QK/QXK) Q_NEW : Allocate a mutable (dynamic) event Q_NEW_X : Non-asserting allocate a mutable (dynamic) event Q_NEW_REF : Create a new reference of the current event e Q_DELETE_REF : Delete the event reference

SAS_QP_OSAL

SAS_QP_OSAL : OS abstraction layer (OSAL)
Description Operating System Abstraction layer (Figure SAS-CTXT [2]) insulates the QP/C Framework from the specifics of the underlying Operating System (OS). The OS Abstraction Layer provides an abstracted OSAL API that QP/C Framework uses internally. The OS Abstraction Layer also implements the OSAL API for the underlying OS layer, which is called a specific QP port.
Backward Traceability SRS_QP_NF_03 : QP/C Framework shall be modular. SRS_QP_NF_04 : QP/C Framework shall be layered.
Forward Traceability

SAS_QP_OS

SAS_QP_OS : OS layer
Description Operating System layer (Figure SAS-CTXT [3]) provides the execution context for Active Objects as well as other services used by the OS abstraction layer (OSAL). The OS Layer might consist of one of the real-time kernels provided in the QP/C Framework (e.g., QV, QK, or QXK) or might be a 3rd-party RTOS/OS.
Backward Traceability SRS_QP_NF_03 : QP/C Framework shall be modular. SRS_QP_NF_04 : QP/C Framework shall be layered. SRS_QP_AO_80 : QP/C Framework shall be portable to a wide range of operating systems.
Forward Traceability

Interface View

The Interface View defines how different layers of a system interact with each other. The objectives are:

• define clear layer boundaries, ensuring each layer's responsibilities and interactions are well-defined.
• ensure compatibility to allow seamless communication and data exchange between layers.
• promote modularity to allow components to be developed, tested, and maintained independently, which enhances flexibility and scalability.
• facilitate integration to provide a blueprint for integrating different components, making it easier to assemble the system and ensure that all parts work together harmoniously.
• enhance reusability by designing interfaces that can be reused across different projects or components, reducing development time and effort.
• support interoperability to ensure that the system can interact with other systems or external components, which is especially important in real-time embedded systems where integration with hardware and other software is common.
• maintain consistency in how components interact, which helps in maintaining the integrity and reliability of the system.

SAS_QP_CLS

SAS_QP_CLS : QP/C Framework base classes
Description Base classes in QP/C Framework (Figure SAS-CTXT [1A]) provide an interface for QP/C Application to inherit and specialize.
Backward Traceability SRS_QP_EVT_00 : QP/C Framework shall provide Event abstraction to QP/C Application SRS_QP_SM_00 : QP/C Framework shall provide support for hierarchical state machines both for Active Objects and for passive event-driven objects in the Application SRS_QP_AO_00 : QP/C Framework shall provide the Active Object abstraction to QP/C Application
Forward Traceability SDS_QA_QHsm_decl : Declaring QHsm subclass. SDS_QA_QHsm_top_init : Implementing the top-most initial pseudo-state. SDS_QA_QHsm_state : Implementing a state and its nesting. SDS_QA_QHsm_entry : Implementing state entry action. SDS_QA_QHsm_exit : Implementing state exit action. SDS_QA_QHsm_nest_init : Implementing nested initial transition. SDS_QA_QHsm_tran : Implementing state transition. SDS_QA_QHsm_intern : Implementing internal transition. SDS_QA_QHsm_choice : Implementing choice point and guard conditions. SDS_QA_QHsm_hist : Implementing state history. SDS_QA_QHsm_hist_tran : Implementing transition to history. SDS_QA_QMsm_decl : Declaring QMsm subclass. SDS_QA_QMsm_top_init : Implementing the top-most initial pseudo-state. SDS_QA_QMsm_state : Implementing a state and its nesting. SDS_QA_QMsm_entry : Implementing state entry action. SDS_QA_QMsm_exit : Implementing state exit action. SDS_QA_QMsm_nest_init : Implementing nested initial transition. SDS_QA_QMsm_tran : Implementing state transition. SDS_QA_QMsm_intern : Implementing internal transition. SDS_QA_QMsm_choice : Implementing choice point and guard conditions. SDS_QA_QMsm_hist : Implementing state history. SDS_QA_QMsm_hist_tran : Implementing transition to history.

SAS_QP_API

SAS_QP_API : QP/C Framework API
Description QP/C Framework API (Figure SAS-CTXT [1B]) provides an interface to various QP/C Framework services without the need to subclass and specialize the QP/C Framework base classes. Examples of such services include: direct event posting, subscribing and publishing events, or arming and disarming time events.
Backward Traceability SRS_QP_EDM_00 : QP/C Framework shall provide direct event posting to Active Object instances based on the FIFO policy SRS_QP_EDM_01 : QP/C Framework shall provide direct event self-posting to Active Object instances based on the LIFO policy SRS_QP_EDM_50 : QP/C Framework shall provide publish-subscribe event delivery mechanism SRS_QP_EDM_52 : QP/C Framework shall allow Active Object instances to subscribe to a given event signal at run-time. SRS_QP_EDM_53 : QP/C Framework shall allow Active Object instances to unsubscribe from a subscribed event signal at run-time. SRS_QP_EDM_54 : QP/C Framework shall allow Active Object instances to unsubscribe from all subscribed event signals at run-time. SRS_QP_EMM_40 : QP/C Framework shall provide a method of explicitly recycling mutable events. SRS_QP_TM_00 : QP/C Framework shall support Time Events. SRS_QP_TM_11 : For every clock rate QP/C Framework shall provide a clock-tick processing operation that QP/C Application must call periodically to service the armed Time Events. SRS_QP_TM_20 : QP/C Framework shall provide Time Event initialization. SRS_QP_TM_21 : QP/C Framework shall allow a Time Event to be armed both for one-shot and periodic expiry. SRS_QP_TM_22 : QP/C Framework shall allow a Time Event to be explicitly disarmed. SRS_QP_TM_23 : QP/C Framework shall allow a Time Event to be rearmed. SRS_QP_TM_30 : QP/C Framework shall provide operation to check whether any Time Events are armed for a given tick rate.
Forward Traceability

SAS_OSAL_API

SAS_OSAL_API : OSAL API
Description OSAL API (Figure SAS-CTXT [2A]) is an abstract interface between QP/C Framework and the underlying OS to insulate the framework from the OS.
Backward Traceability SRS_QP_NF_40 : QP/C Framework shall be portable to 16-/32-/64-bit CPUs. SRS_QP_NF_41 : QP/C Framework shall be portable to a wide range of real-time kernels.
Forward Traceability

SAS_OS_API

SAS_OS_API : OS API
Description OS API (Figure SAS-CTXT [2B]) is the specific Operating System API. This interface is not part of QP/C Framework, but is used in every specific OS Abstraction layer (OSAL).
Forward Traceability

Technology ViewpointResource Viewpoint