Native QF Event Queue. More...

#include "qequeue.h"

Public Member Functions
void	QEQueue_init (QEQueue const me, struct QEvt const *const qSto, uint_fast16_t const qLen)

bool	QEQueue_post (QEQueue const me, struct QEvt const const e, uint_fast16_t const margin, uint_fast8_t const qsId)
	Post an event to the "raw" thread-safe event queue (FIFO)

void	QEQueue_postLIFO (QEQueue const me, struct QEvt const const e, uint_fast8_t const qsId)
	Post an event to the "raw" thread-safe event queue (LIFO)

struct QEvt const *	QEQueue_get (QEQueue *const me, uint_fast8_t const qsId)
	Obtain an event from the "raw" thread-safe queue.

Static Public Member Functions
static QEQueueCtr	QEQueue_getNFree (QEQueue const *const me)
	Obtain the number of free entries still available in the queue.

static QEQueueCtr	QEQueue_getNMin (QEQueue const *const me)
	Obtain the minimum number of free entries ever in the queue (a.k.a. "low-watermark")

static bool	QEQueue_isEmpty (QEQueue const *const me)
	Find out if the queue is empty.

Private Attributes
struct QEvt const *volatile	frontEvt
	Pointer to event at the front of the queue.

struct QEvt const **	ring
	Pointer to the start of the ring buffer.

QEQueueCtr	end
	Offset of the end of the ring buffer from the start of the buffer.

QEQueueCtr volatile	head
	Offset to where next event will be inserted into the buffer.

QEQueueCtr volatile	tail
	Offset of where next event will be extracted from the buffer.

QEQueueCtr volatile	nFree
	Number of free events in the ring buffer.

uintptr_t	frontEvt_dis

QEQueueCtr	head_dis

QEQueueCtr	tail_dis

QEQueueCtr	nFree_dis

QEQueueCtr	nMin
	Minimum number of free events ever in the ring buffer.

Detailed Description

Native QF Event Queue.

Details: This class describes the native QF event queue, which can be used as the event queue for active objects, or as a simple "raw" event queue for thread-safe event passing among non-framework entities, such as ISRs, device drivers, or other third-party components.

The native QF event queue is configured by defining the macro QACTIVE_EQUEUE_TYPE as QEQueue in the specific QF port header file.

The QEQueue structure contains only data members for managing an event queue, but does not contain the storage for the queue buffer, which must be provided externally during the queue initialization.

The event queue can store only event pointers, not the whole events. The internal implementation uses the standard ring-buffer plus one external location that optimizes the queue operation for the most frequent case of empty queue.

The QEQueue structure is used with two sets of functions. One set is for the active object event queue, which might need to block the active object task when the event queue is empty and might need to unblock it when events are posted to the queue. The interface for the native active object event queue consists of the following functions: QActive_post(), QActive_postLIFO(), and QActive_get_(). Additionally the function QEQueue_initX() is used to initialize the queue.

The other set of functions, uses QEQueue as a simple "raw" event queue to pass events between entities other than active objects, such as ISRs. The "raw" event queue is not capable of blocking on the get() operation, but is still thread-safe because it uses QF critical section to protect its integrity. The interface for the "raw" thread-safe queue consists of the following functions: QEQueue_post(), QEQueue_postLIFO(), and QEQueue_get(). Additionally the function QEQueue_initX() is used to initialize the queue.

Most event queue operations (both the active object queues and the "raw" queues) internally use the QF critical section. You should be careful not to invoke those operations from other critical sections when nesting of critical sections is not supported.

See also: QEQueue for the description of the data members

Definition at line 56 of file qequeue.h.

Member Function Documentation

◆ QEQueue_init()

void QEQueue_init	(	QEQueue *const	me,
		struct QEvt const **const	qSto,
		uint_fast16_t const	qLen )

◆ QEQueue_post()

bool QEQueue_post	(	QEQueue *const	me,
		struct QEvt const *const	e,
		uint_fast16_t const	margin,
		uint_fast8_t const	qsId )

Post an event to the "raw" thread-safe event queue (FIFO)

Details: Post an event to the "raw" thread-safe event queue using the First-In-First-Out (FIFO) order.

Parameters

[in,out]	me	current instance pointer (see oop)
[in]	e	pointer to the event to be posted to the queue
[in]	margin	number of required free slots in the queue after posting the event. The special value QF_NO_MARGIN means that this function will assert if posting
[in]	qsId	QS-id of this state machine (for QS local filter)

Returns: 'true' (success) when the posting succeeded with the provided margin and 'false' (failure) when the posting fails.

Precondition qf_qeq:200

event must be valid

Note: The QF_NO_MARGIN value of the margin parameter is special and denotes situation when the post() operation is assumed to succeed (event delivery guarantee). An assertion fires, when the event cannot be delivered in this case.; This function can be called from any task context or ISR context.

See also

QEQueue_postLIFO()
QEQueue_get()

Definition at line 95 of file qf_qeq.c.

◆ QEQueue_postLIFO()

void QEQueue_postLIFO	(	QEQueue *const	me,
		struct QEvt const *const	e,
		uint_fast8_t const	qsId )

Post an event to the "raw" thread-safe event queue (LIFO)

Details: Post an event to the "raw" thread-safe event queue using the Last-In-First-Out (LIFO) order.

Parameters

[in,out]	me	current instance pointer (see oop)
[in]	e	pointer to the event to be posted to the queue
[in]	qsId	QS-id of this state machine (for QS local filter)

Precondition qf_qeq:300

the queue must be able to accept the event (cannot overflow)

Attention: The LIFO policy should be used only with great caution, because it alters the order of events in the queue.

Note: This function can be called from any task context or ISR context.; this function is used for the "raw" thread-safe queues and not for the queues of active objects.

See also

QEQueue_post()
QEQueue_get()
QActive_defer()

Definition at line 210 of file qf_qeq.c.

◆ QEQueue_get()

struct QEvt const * QEQueue_get	(	QEQueue *const	me,
		uint_fast8_t const	qsId )

Obtain an event from the "raw" thread-safe queue.

Details: Retrieves an event from the front of the "raw" thread-safe queue and returns a pointer to this event to the caller.

Parameters

[in,out]	me	current instance pointer (see oop)
[in]	qsId	QS-id of this state machine (for QS local filter)

Returns: pointer to event at the front of the queue, if the queue is not empty and NULL if the queue is empty.

Note: This function is used for the "raw" thread-safe queues and not for the queues of active objects.

See also

QEQueue_post()
QEQueue_postLIFO()
QActive_recall()

Definition at line 298 of file qf_qeq.c.

◆ QEQueue_getNFree()

static QEQueueCtr QEQueue_getNFree ( QEQueue const *const me )

inlinestatic

Obtain the number of free entries still available in the queue.

Details: This operation needs to be used with caution because the number of free entries can change unexpectedly. The main intent for using this operation is in conjunction with event deferral. In this case the queue is accessed only from a single thread (by a single AO), so the number of free entries cannot change unexpectedly.

Parameters

[in] me current instance pointer (see oop)

Returns: the current number of free slots in the queue.

Definition at line 131 of file qequeue.h.

◆ QEQueue_getNMin()

static QEQueueCtr QEQueue_getNMin ( QEQueue const *const me )

inlinestatic

Obtain the minimum number of free entries ever in the queue (a.k.a. "low-watermark")

Details: This operation needs to be used with caution because the "low-watermark" can change unexpectedly. The main intent for using this operation is to get an idea of queue usage to size the queue adequately.

Parameters

[in] me current instance pointer (see oop)

Returns: the minimum number of free entries ever in the queue since init.

Definition at line 136 of file qequeue.h.

◆ QEQueue_isEmpty()

static bool QEQueue_isEmpty ( QEQueue const *const me )

inlinestatic

Find out if the queue is empty.

Details: This operation needs to be used with caution because the queue status can change unexpectedly. The main intent for using this operation is in conjunction with event deferral. In this case the queue is accessed only from a single thread (by a single AO), so no other entity can post events to the queue.

Parameters

[in,out] me current instance pointer (see oop)

Returns: 'true' if the queue is current empty and 'false' otherwise.

Definition at line 145 of file qequeue.h.

Member Data Documentation

◆ frontEvt

struct QEvt const* volatile frontEvt

private

Pointer to event at the front of the queue.

Details: All incoming and outgoing events pass through the frontEvt location. When the queue is empty (which is most of the time), the extra frontEvt location allows to bypass the ring buffer altogether, greatly optimizing the performance of the queue. Only bursts of events engage the ring buffer.

The additional role of this attribute is to indicate the empty status of the queue. The queue is empty when frontEvt is NULL.

Definition at line 60 of file qequeue.h.

◆ ring

struct QEvt const* * ring

private

Pointer to the start of the ring buffer.

Definition at line 63 of file qequeue.h.

◆ end

QEQueueCtr end

private

Offset of the end of the ring buffer from the start of the buffer.

Definition at line 66 of file qequeue.h.

◆ head

QEQueueCtr volatile head

private

Offset to where next event will be inserted into the buffer.

Definition at line 69 of file qequeue.h.

◆ tail

QEQueueCtr volatile tail

private

Offset of where next event will be extracted from the buffer.

Definition at line 72 of file qequeue.h.

◆ nFree

QEQueueCtr volatile nFree

private

Number of free events in the ring buffer.

Definition at line 75 of file qequeue.h.

◆ frontEvt_dis

uintptr_t frontEvt_dis

private

Definition at line 79 of file qequeue.h.

◆ head_dis

QEQueueCtr head_dis

private

Definition at line 84 of file qequeue.h.

◆ tail_dis

QEQueueCtr tail_dis

private

Definition at line 89 of file qequeue.h.

◆ nFree_dis

QEQueueCtr nFree_dis

private

Definition at line 94 of file qequeue.h.

◆ nMin

QEQueueCtr nMin

private

Minimum number of free events ever in the ring buffer.

Details: This attribute remembers the low-watermark of the ring buffer, which provides a valuable information for sizing event queues.

See also

QF_getQueueMargin()

Definition at line 99 of file qequeue.h.

The documentation for this class was generated from the following files:

Public Member Functions

Static Public Member Functions

Private Attributes

Detailed Description

Member Function Documentation

◆ QEQueue_init()

◆ QEQueue_post()

◆ QEQueue_postLIFO()

◆ QEQueue_get()

◆ QEQueue_getNFree()

◆ QEQueue_getNMin()

◆ QEQueue_isEmpty()

Member Data Documentation

◆ frontEvt

◆ ring

◆ end

◆ head

◆ tail

◆ nFree

◆ frontEvt_dis

◆ head_dis

◆ tail_dis

◆ nFree_dis

◆ nMin