stk::sync::Event Class Reference

Binary synchronization event (signaled / non-signaled) primitive. More...

#include <stk_sync_event.h>

Inheritance diagram for stk::sync::Event:

Collaboration diagram for stk::sync::Event:

Public Member Functions
	Event (bool manual_reset=false, bool initial_state=false)
	Constructor.
	~Event ()
	Destructor.
bool	Set ()
	Set event to signaled state.
bool	Reset ()
	Reset event to non-signaled state.
bool	Wait (Timeout timeout_ticks=WAIT_INFINITE)
	Wait until event becomes signaled or the timeout expires.
bool	TryWait ()
	Poll event state without blocking.
void	Pulse ()
	Pulse event: attempt to release waiters and then reset (Win32 PulseEvent() semantics).
void	SetTraceName (const char *name)
	Set name.
const char *	GetTraceName () const
	Get name.

Private Types
typedef DLHeadType	ListHeadType
	List head type for ISyncObject elements.
typedef DLEntryType	ListEntryType
	List entry type of ISyncObject elements.
enum
	A tag for type-safe casts done by CastListEntryToParent. More...
typedef DListEntry< ISyncObject, TClosedLoop >	DLEntryType
	Convenience alias for this entry type. Used to avoid repeating the full template spelling.
typedef DListHead< ISyncObject, TClosedLoop >	DLHeadType
	Convenience alias for the corresponding list head type.

Private Member Functions
	Event (const Event &)=delete
Event &	operator= (const Event &)=delete
void	RemoveWaitObject (IWaitObject *wobj) override
	Called by kernel when a waiting task is being removed (timeout expired, wait aborted, task terminated etc.).
virtual void	AddWaitObject (IWaitObject *wobj)
	Called by kernel when a new task starts waiting on this event.
virtual bool	Tick (Timeout elapsed_ticks)
	Called by kernel on every system tick to handle timeout logic of waiting tasks.
Weight	FindWeightHigherThan (Weight comp) const
	Find higher weight within linked wait objects.
void	WakeOne ()
	Wake the first task in the wait list (FIFO order).
void	WakeAll ()
	Wake all tasks currently in the wait list.
DLHeadType *	GetHead ()
	Get the list head this entry currently belongs to.
DLEntryType *	GetNext ()
	Get the next entry in the list.
DLEntryType *	GetPrev ()
	Get the previous entry in the list.
bool	IsLinked () const
	Check whether this entry is currently a member of any list.
	operator ISyncObject * ()
	Implicit conversion to a mutable pointer to the host object (T).
	operator const ISyncObject * () const
	Implicit conversion to a const pointer to the host object (T).
void	Link (DLHeadType *head, DLEntryType *next, DLEntryType *prev)
	Wire this entry into a list between prev and next.
void	Unlink ()
	Remove this entry from its current list.

Private Attributes
bool	m_manual_reset
	true = manual-reset event, false = auto-reset
bool	m_signaled
	current signaled state of the event
IWaitObject::ListHeadType	m_wait_list
	tasks blocked on this object
DLHeadType *	m_head
	Owning list head, or NULL when the entry is not linked.
DLEntryType *	m_next
	Next entry in the list, or NULL (open list boundary) / first entry (closed loop).
DLEntryType *	m_prev
	Previous entry in the list, or NULL (open list boundary) / last entry (closed loop).

Detailed Description

Binary synchronization event (signaled / non-signaled) primitive.

Supports two operation modes:

• Auto-reset (default): Set() wakes one waiting task and automatically resets.
• Manual-reset: Set() wakes all waiting tasks; state remains signaled until Reset().

Additionally, supports Pulse(): attempt to release waiters and then reset (Win32 PulseEvent() semantics).

Note

Follows Win32 PulseEvent() behavior:

• For auto-reset events: releases one waiting thread (if any) and resets to non-signaled.
• For manual-reset events: releases all waiting threads (if any) and resets to non-signaled.
• If no threads are waiting, resets to non-signaled.

Warning

Pulse semantics are inherently racy and considered unreliable in many Win32 usage scenarios. Prefer explicit Set() + Reset() patterns when possible.

// Example: Task synchronization using Event
stk::sync::Event g_DataReadyEvt;
 
void Task_Producer() {
    // ... produce data ...
 
    // notify Task_Consumer that data is ready
    g_DataReadyEvt.Set();
}
 
void Task_Consumer() {
    // wait for a data-ready notification signal from Task_Producer with 1s timeout
    if (g_DataReadyEvt.Wait(1000)) {
        // ... process data ...
    }
}

See also

ISyncObject, IWaitObject, IKernelService::Wait

Note

Only available when kernel is compiled with KERNEL_SYNC mode enabled.

Definition at line 61 of file stk_sync_event.h.

Member Typedef Documentation

DLEntryType

typedef DListEntry<ISyncObject, TClosedLoop> stk::util::DListEntry< ISyncObject, TClosedLoop >::DLEntryType

inherited

Convenience alias for this entry type. Used to avoid repeating the full template spelling.

Definition at line 75 of file stk_linked_list.h.

DLHeadType

typedef DListHead<ISyncObject, TClosedLoop> stk::util::DListEntry< ISyncObject, TClosedLoop >::DLHeadType

inherited

Convenience alias for the corresponding list head type.

Definition at line 80 of file stk_linked_list.h.

ListEntryType

typedef DLEntryType stk::ISyncObject::ListEntryType

inherited

List entry type of ISyncObject elements.

Definition at line 451 of file stk_common.h.

ListHeadType

typedef DLHeadType stk::ISyncObject::ListHeadType

inherited

List head type for ISyncObject elements.

Definition at line 446 of file stk_common.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

inherited

A tag for type-safe casts done by CastListEntryToParent.

See also

CastListEntryToParent.

Definition at line 70 of file stk_linked_list.h.

{ DLEntryTag = 1 };

Constructor & Destructor Documentation

Event() [1/2]

stk::sync::Event::Event ( bool manual_reset = false, bool initial_state = false )

inlineexplicit

Constructor.

Parameters

[in]	manual_reset	If true creates a manual-reset event (stays signaled until explicitly reset). If false (default) creates an auto-reset event.
[in]	initial_state	Initial state of the event: true = signaled, false = non-signaled.

Definition at line 69 of file stk_sync_event.h.

        : m_manual_reset(manual_reset), m_signaled(initial_state)
    {}

References m_manual_reset, and m_signaled.

Referenced by Event().

Here is the caller graph for this function:

~Event()

stk::sync::Event::~Event ( )

inline

Destructor.

Note

If tasks are still waiting at destruction time it is considered a logical error (dangling waiters). An assertion is triggered in debug builds.

MISRA deviation: [STK-DEV-005] Rule 10-3-2.

Definition at line 78 of file stk_sync_event.h.

    {
        STK_ASSERT(m_wait_list.IsEmpty()); // API contract: must not be destroyed with waiting tasks
    }

References stk::ISyncObject::m_wait_list, STK_ASSERT, and STK_VIRT_DTOR.

Event() [2/2]

stk::sync::Event::Event ( const Event & )

privatedelete

References Event().

Here is the call graph for this function:

Member Function Documentation

AddWaitObject()

virtual void stk::ISyncObject::AddWaitObject ( IWaitObject * wobj )

inlinevirtualinherited

Called by kernel when a new task starts waiting on this event.

Parameters

[in]

wobj

Wait object representing blocked task.

Note

Must be called inside the critical section (see hw::CriticalSection, sync::ScopedCrticalSection).

Definition at line 457 of file stk_common.h.

    {
        STK_ASSERT(wobj->GetHead() == nullptr);
        m_wait_list.LinkBack(wobj);
    }

References stk::util::DListEntry< T, TClosedLoop >::GetHead(), m_wait_list, and STK_ASSERT.

Referenced by stk::Kernel< TMode, TSize, TStrategy, TPlatform >::KernelTask::WaitObject::SetupWait().

Here is the call graph for this function:

Here is the caller graph for this function:

FindWeightHigherThan()

Weight stk::ISyncObject::FindWeightHigherThan ( Weight comp ) const

inlineinherited

Find higher weight within linked wait objects.

Implementation of ISyncObject::Tick, see ISyncObject. Placed here as it depends on GetUserTaskFromTid.

Parameters

[in]

comp

Weight to compare with.

Returns

Higher weight value than comp, or NO_WEIGHT if there is no object with a higher weight.

Note

Must be called inside the critical section (see hw::CriticalSection, sync::ScopedCrticalSection).

Definition at line 214 of file stk_helper.h.

{
    Weight max_weight = NO_WEIGHT;
    const IWaitObject *itr = util::DListCast::ListEntryToParent<const IWaitObject>(m_wait_list.GetFirst());     
 
    while (itr != nullptr)
    {
        const Weight w = GetUserTaskFromTid(itr->GetTid())->GetWeight();
        if (w > max_weight)
        {
            max_weight = w;
        }
            
        itr = util::DListCast::ListEntryToParent<const IWaitObject>(itr->GetNext());
    }
 
    return ((max_weight > comp) ? max_weight : NO_WEIGHT);
}

References stk::util::DListEntry< T, TClosedLoop >::GetNext(), stk::IWaitObject::GetTid(), stk::GetUserTaskFromTid(), stk::ITask::GetWeight(), stk::util::DListCast::ListEntryToParent(), m_wait_list, and stk::NO_WEIGHT.

Referenced by stk::Kernel< stk::KERNEL_DYNAMIC|stk::KERNEL_SYNC|stk::KERNEL_TICKLESS,(16U), stk::SwitchStrategyFP32, stk::PlatformDefault >::OnRestoreWeight(), and stk::sync::Mutex::Unlock().

Here is the call graph for this function:

Here is the caller graph for this function:

GetHead()

DLHeadType * stk::util::DListEntry< ISyncObject, TClosedLoop >::GetHead ( )

inlineinherited

Get the list head this entry currently belongs to.

Returns

Pointer to the owning DListHead, or NULL if the entry is not linked.

Definition at line 85 of file stk_linked_list.h.

{ return m_head; }

GetNext()

DLEntryType * stk::util::DListEntry< ISyncObject, TClosedLoop >::GetNext ( )

inlineinherited

Get the next entry in the list.

Returns

Pointer to the next DListEntry, or NULL if this is the last entry (open list) or the first entry (closed loop, where next wraps to first).

Note

In a closed loop (TClosedLoop == true) this pointer is never NULL when the entry is linked.

Definition at line 98 of file stk_linked_list.h.

{ return m_next; }

GetPrev()

DLEntryType * stk::util::DListEntry< ISyncObject, TClosedLoop >::GetPrev ( )

inlineinherited

Get the previous entry in the list.

Returns

Pointer to the previous DListEntry, or NULL if this is the first entry (open list) or the last entry (closed loop, where prev wraps to last).

Note

In a closed loop (TClosedLoop == true) this pointer is never NULL when the entry is linked.

Definition at line 114 of file stk_linked_list.h.

{ return m_prev; }

GetTraceName()

const char * stk::ITraceable::GetTraceName ( ) const

inlineinherited

Get name.

Returns

Name string, or NULL if not set or if STK_SYNC_DEBUG_NAMES is 0.

Definition at line 416 of file stk_common.h.

    {
    #if STK_SYNC_DEBUG_NAMES
        return m_trace_name;
    #else
        return nullptr;
    #endif
    }

IsLinked()

bool stk::util::DListEntry< ISyncObject, TClosedLoop >::IsLinked ( ) const

inlineinherited

Check whether this entry is currently a member of any list.

Returns

true if linked (m_head != NULL); false otherwise.

Definition at line 127 of file stk_linked_list.h.

{ return (GetHead() != nullptr); }

Link()

void stk::util::DListEntry< ISyncObject, TClosedLoop >::Link ( DLHeadType * head, DLEntryType * next, DLEntryType * prev )

inlineprivateinherited

Wire this entry into a list between prev and next.

Parameters

[in]	head	The owning DListHead. Stored as a back-pointer for IsLinked() and ownership checks.
[in]	next	The entry that will follow this one, or NULL if this becomes the last entry.
[in]	prev	The entry that will precede this one, or NULL if this becomes the first entry.

Note

Called exclusively by DListHead::Link(). Assumes the entry is not currently linked. Updates the neighbours' forward/back pointers to splice this entry in.

Definition at line 162 of file stk_linked_list.h.

    {
        m_head = head;
        m_next = next;
        m_prev = prev;
 
        if (m_prev != nullptr)
        {
            m_prev->m_next = this;
        }
 
        if (m_next != nullptr)
        {
            m_next->m_prev = this;
        }
    }

operator const ISyncObject *()

stk::util::DListEntry< ISyncObject, TClosedLoop >::operator const ISyncObject * ( ) const

inlineinherited

Implicit conversion to a const pointer to the host object (T).

Note

Safe because T must derive from DListEntry<T, TClosedLoop>. Eliminates the need for explicit static_cast at call sites.

MISRA deviation: [STK-DEV-004] Rule 5-2-x.

Definition at line 141 of file stk_linked_list.h.

{ return static_cast<const T *>(this); }

operator ISyncObject *()

stk::util::DListEntry< ISyncObject, TClosedLoop >::operator ISyncObject* ( )

inlineinherited

Implicit conversion to a mutable pointer to the host object (T).

Note

Safe because T must derive from DListEntry<T, TClosedLoop>. Eliminates the need for explicit static_cast at call sites.

MISRA deviation: [STK-DEV-004] Rule 5-2-x.

Definition at line 134 of file stk_linked_list.h.

{ return static_cast<T *>(this); }

operator=()

Event & stk::sync::Event::operator= ( const Event & )

privatedelete

Pulse()

void stk::sync::Event::Pulse ( )

inline

Pulse event: attempt to release waiters and then reset (Win32 PulseEvent() semantics).

Note

Follows Win32 PulseEvent() behavior:

• For auto-reset events: releases one waiting thread (if any) and resets to non-signaled.
• For manual-reset events: releases all waiting threads (if any) and resets to non-signaled.
• If no threads are waiting, resets to non-signaled.

ISR-safe.

Warning

Pulse semantics are inherently racy and considered unreliable in many Win32 usage scenarios. Prefer explicit Set() + Reset() patterns when possible.

Definition at line 194 of file stk_sync_event.h.

{
    const ScopedCriticalSection cs_;
 
    // transition to signaled so that WakeOne/WakeAll can release waiters:
    // m_signaled is only visible as true while this critical section is held —
    // any woken task will have the event auto-reset in RemoveWaitObject before
    // it can observe m_signaled via Wait() or TryWait()
    m_signaled = true;
    __stk_full_memfence();
 
    if (!m_wait_list.IsEmpty())
    {
        if (m_manual_reset)
        {
            WakeAll();
        }
        else
        {
            WakeOne(); // auto-reset applied in RemoveWaitObject
        }
    }
 
    // force return to non-signaled regardless of whether anyone was waiting
    m_signaled = false;
    __stk_full_memfence();
}

References m_manual_reset, m_signaled, stk::ISyncObject::m_wait_list, stk::ISyncObject::WakeAll(), and stk::ISyncObject::WakeOne().

Referenced by stk_event_pulse().

Here is the call graph for this function:

Here is the caller graph for this function:

RemoveWaitObject()

void stk::sync::Event::RemoveWaitObject ( IWaitObject * wobj )

inlineoverrideprivatevirtual

Called by kernel when a waiting task is being removed (timeout expired, wait aborted, task terminated etc.).

Parameters

[in]

wobj

Wait object to remove from the wait list.

Note

Must be called inside the critical section (see hw::CriticalSection, sync::ScopedCrticalSection).

Reimplemented from stk::ISyncObject.

Definition at line 285 of file stk_sync_event.h.

{
    ISyncObject::RemoveWaitObject(wobj);
 
    // kernel invariant: auto-reset is applied here, not at the Set()/Pulse() call site,
    // when a task wakes due to a signal (not a timeout), the event transitions back to
    // non-signaled so that subsequent Wait() calls block until the next Set().
    if (!m_manual_reset && m_signaled)
    {
        if (!wobj->IsTimeout())
        {
            m_signaled = false;
            __stk_full_memfence();
        }
    }
}

References stk::IWaitObject::IsTimeout(), m_manual_reset, m_signaled, and stk::ISyncObject::RemoveWaitObject().

Here is the call graph for this function:

Reset()

bool stk::sync::Event::Reset ( )

inline

Reset event to non-signaled state.

Returns

true if state was changed from signaled to non-signaled, false if event was already non-signaled.

Note

Has no practical effect on auto-reset events that are already non-signaled. Mainly used with manual-reset events.

ISR-safe.

Definition at line 178 of file stk_sync_event.h.

{
    const ScopedCriticalSection cs_;
 
    const bool prev = m_signaled;
 
    m_signaled = false;
    __stk_full_memfence();
 
    return prev;
}

References m_signaled.

Referenced by stk_event_reset().

Here is the caller graph for this function:

Set()

bool stk::sync::Event::Set ( )

inline

Set event to signaled state.

Returns

true if state was changed from non-signaled to signaled, false if event was already signaled.

Note

- In auto-reset mode: wakes one waiting task (if any) and immediately resets.

• In manual-reset mode: wakes all waiting tasks (if any); state remains set.
• If already signaled, does nothing and returns false.

Warning

The return value indicates whether the event state changed, not whether any waiting task was woken. A return of false means the event was already signaled, not that no task woke.

Note

ISR-safe.

Definition at line 147 of file stk_sync_event.h.

{
    const ScopedCriticalSection cs_;
    bool status = true;
 
    if (m_signaled)
    {
        status = false;
    }
    else
    {
        m_signaled = true;
        __stk_full_memfence();
 
        if (m_manual_reset)
        {
            WakeAll();
        }
        else
        {
            WakeOne(); // auto-reset is applied in RemoveWaitObject when the waiter is removed
        }
    }
 
    return status;
}

References m_manual_reset, m_signaled, stk::ISyncObject::WakeAll(), and stk::ISyncObject::WakeOne().

Referenced by stk_event_set().

Here is the call graph for this function:

Here is the caller graph for this function:

SetTraceName()

void stk::ITraceable::SetTraceName ( const char * name )

inlineinherited

Set name.

Parameters

[in]

name

Null-terminated string or NULL.

Note

If STK_SYNC_DEBUG_NAMES is 0 then calling this function has no effect.

Definition at line 404 of file stk_common.h.

    {
    #if STK_SYNC_DEBUG_NAMES
        m_trace_name = name;
    #else
        STK_UNUSED(name);
    #endif
    }

References STK_UNUSED.

Referenced by stk::memory::BlockMemoryPool::BlockMemoryPool(), and stk::memory::BlockMemoryPool::BlockMemoryPool().

Here is the caller graph for this function:

Tick()

bool stk::ISyncObject::Tick ( Timeout elapsed_ticks )

inlinevirtualinherited

Called by kernel on every system tick to handle timeout logic of waiting tasks.

Implementation of ISyncObject::Tick, see ISyncObject. Placed here as it depends on hw namespace.

Parameters

[in]

elapsed_ticks

Number of ticks elapsed between this and previous calls, in case of KERNEL_TICKLESS mode this value can be >1, for non-tickless mode it is always 1.

Returns

true if this synchronization object still has waiters with a finite timeout and requires further tick calls. false if the wait list is empty or all remaining waiters have infinite timeouts, signaling to the kernel that it may stop calling Tick() for this object until a new waiter is added.

Note

When this method returns false, the kernel unlinks this object from its active sync list. It will be re-linked automatically when the next waiter is added via AddWaitObject().

Does not need to be called inside critical section.

Definition at line 181 of file stk_helper.h.

{
    // note: ScopedCriticalSection usage
    //
    // Single-core: no critical section needed - Tick() runs inside the
    // SysTick ISR which already executes with interrupts disabled, making
    // re-entrancy impossible on the local core.
    //
    // Multi-core: critical section is required because the tick handler on
    // each core may call Tick() concurrently for the same Semaphore instance,
    // and ISyncObject::Tick() is not re-entrant.
#if (STK_ARCH_CPU_COUNT > 1)
    hw::CriticalSection::ScopedLock cs_;
#endif
 
    IWaitObject *itr = util::DListCast::ListEntryToParent<IWaitObject>(m_wait_list.GetFirst());
 
    while (itr != nullptr)
    {
        IWaitObject *const next = util::DListCast::ListEntryToParent<IWaitObject>(itr->GetNext());
 
        if (!itr->Tick(elapsed_ticks))
        {
            itr->Wake(true);
        }
 
        itr = next;
    }
 
    return !m_wait_list.IsEmpty();
}

References stk::util::DListEntry< T, TClosedLoop >::GetNext(), stk::util::DListCast::ListEntryToParent(), m_wait_list, stk::IWaitObject::Tick(), and stk::IWaitObject::Wake().

Here is the call graph for this function:

TryWait()

bool stk::sync::Event::TryWait ( )

inline

Poll event state without blocking.

Checks if the event is currently signaled. If signaled, performs the auto-reset (if auto-reset mode is active) and returns immediately without yielding the CPU or entering a wait list.

Note

ISR-safe.

Returns

true if event was signaled at the time of the call, false if event was not signaled.

Definition at line 262 of file stk_sync_event.h.

{
    const ScopedCriticalSection cs_;
    bool result = false;
 
    if (m_signaled)
    {
        if (!m_manual_reset)
        {
            m_signaled = false;
            __stk_full_memfence();
        }
 
        result = true;
    }
 
    return result;
}

References m_manual_reset, and m_signaled.

Referenced by stk_event_trywait().

Here is the caller graph for this function:

Unlink()

void stk::util::DListEntry< ISyncObject, TClosedLoop >::Unlink ( )

inlineprivateinherited

Remove this entry from its current list.

Note

Called exclusively by DListHead::Unlink(). Patches the neighbours' pointers to bridge over this entry, then clears m_head, m_next, and m_prev to NULL so the entry is in a clean unlinked state.

Does not update DListHead::m_count or m_first / m_last — those are the responsibility of the calling DListHead::Unlink().

Definition at line 186 of file stk_linked_list.h.

    {
        if (m_prev != nullptr)
        {
            m_prev->m_next = m_next;
        }
 
        if (m_next != nullptr)
        {
            m_next->m_prev = m_prev;
        }
 
        m_head = nullptr;
        m_next = nullptr;
        m_prev = nullptr;
    }

Wait()

bool stk::sync::Event::Wait ( Timeout timeout_ticks = WAIT_INFINITE )

inline

Wait until event becomes signaled or the timeout expires.

Parameters

[in]

timeout_ticks

Maximum time to wait (ticks). Use WAIT_INFINITE for no timeout (wait forever).

Warning

ISR-safe only with timeout_ticks = NO_WAIT, ISR-unsafe otherwise.

Returns

true if event was signaled (wait succeeded), false if timeout occurred before the event was signaled.

Definition at line 226 of file stk_sync_event.h.

{
    STK_ASSERT(!hw::IsInsideISR()); // API contract: caller must not be in ISR
 
    ScopedCriticalSection cs_;
    bool success = false;
 
    // fast path: already signaled
    if (m_signaled)
    {
        if (!m_manual_reset)
        {
            m_signaled = false;
            __stk_full_memfence();
        }
 
        success = true;
    }
    // slow path: block until Set() signals the event or timeout expires
    else if (timeout_ticks != NO_WAIT)
    {
        success = !IKernelService::GetInstance()->Wait(this, &cs_, timeout_ticks)->IsTimeout();
    }
    else
    {
        // non-blocking poll: event not signaled, return immediately
        // success is already false, so noop
    }
 
    return success;
}

References stk::IKernelService::GetInstance(), stk::hw::IsInsideISR(), stk::IWaitObject::IsTimeout(), m_manual_reset, m_signaled, stk::NO_WAIT, STK_ASSERT, and stk::IKernelService::Wait().

Referenced by stk_event_wait().

Here is the call graph for this function:

Here is the caller graph for this function:

WakeAll()

void stk::ISyncObject::WakeAll ( )

inlineprotectedinherited

Wake all tasks currently in the wait list.

Note

Each woken task is notified with timeout=false, indicating a successful signal (not a timeout expiry).

Does nothing if no tasks are currently waiting.

Must be called inside the critical section (see hw::CriticalSection, sync::ScopedCrticalSection).

Definition at line 526 of file stk_common.h.

    {
        while (IWaitObject *const obj = util::DListCast::ListEntryToParent<IWaitObject>(m_wait_list.GetFirst()))
        {
            obj->Wake(false);
        }
    }

References stk::util::DListCast::ListEntryToParent(), and m_wait_list.

Referenced by stk::sync::ConditionVariable::NotifyAll_CS(), stk::sync::Event::Pulse(), and stk::sync::Event::Set().

Here is the call graph for this function:

Here is the caller graph for this function:

WakeOne()

void stk::ISyncObject::WakeOne ( )

inlineprotectedinherited

Wake the first task in the wait list (FIFO order).

Note

The woken task is notified with timeout=false, indicating a successful signal (not a timeout expiry).

Does nothing if no tasks are currently waiting.

Must be called inside the critical section (see hw::CriticalSection, sync::ScopedCrticalSection).

Definition at line 512 of file stk_common.h.

    {      
        if (IWaitObject *const obj = util::DListCast::ListEntryToParent<IWaitObject>(m_wait_list.GetFirst()))
        {
            obj->Wake(false);
        }
    }

References stk::util::DListCast::ListEntryToParent(), and m_wait_list.

Referenced by stk::sync::ConditionVariable::NotifyOne_CS(), stk::sync::Event::Pulse(), stk::sync::Event::Set(), and stk::sync::Semaphore::Signal().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_head

DLHeadType* stk::util::DListEntry< ISyncObject, TClosedLoop >::m_head

privateinherited

Owning list head, or NULL when the entry is not linked.

Definition at line 203 of file stk_linked_list.h.

m_manual_reset

bool stk::sync::Event::m_manual_reset

private

true = manual-reset event, false = auto-reset

Definition at line 139 of file stk_sync_event.h.

Referenced by Event(), Pulse(), RemoveWaitObject(), Set(), TryWait(), and Wait().

m_next

DLEntryType* stk::util::DListEntry< ISyncObject, TClosedLoop >::m_next

privateinherited

Next entry in the list, or NULL (open list boundary) / first entry (closed loop).

Definition at line 204 of file stk_linked_list.h.

m_prev

DLEntryType* stk::util::DListEntry< ISyncObject, TClosedLoop >::m_prev

privateinherited

Previous entry in the list, or NULL (open list boundary) / last entry (closed loop).

Definition at line 205 of file stk_linked_list.h.

m_signaled

bool stk::sync::Event::m_signaled

private

current signaled state of the event

Definition at line 140 of file stk_sync_event.h.

Referenced by Event(), Pulse(), RemoveWaitObject(), Reset(), Set(), TryWait(), and Wait().

m_wait_list

IWaitObject::ListHeadType stk::ISyncObject::m_wait_list

protectedinherited

tasks blocked on this object

Definition at line 534 of file stk_common.h.

Referenced by AddWaitObject(), FindWeightHigherThan(), ISyncObject(), stk::sync::Event::Pulse(), RemoveWaitObject(), stk::sync::Semaphore::Signal(), Tick(), stk::sync::Mutex::Unlock(), WakeAll(), WakeOne(), stk::sync::ConditionVariable::~ConditionVariable(), stk::sync::Event::~Event(), stk::sync::Mutex::~Mutex(), and stk::sync::Semaphore::~Semaphore().

---

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

• stk_sync_event.h