stk::time::TimerHost Class Reference

Software timer multiplexer that manages multiple Timer instances on top of a small fixed set of kernel tasks. More...

#include <stk_time_timer.h>

Collaboration diagram for stk::time::TimerHost:

Classes
class	Timer
	Abstract base class for a timer managed by TimerHost. More...
class	TimerWorkerTask
	The actual task that executes timer callback. More...
struct	TimerCommand

Public Types
enum	EConsts {   TASK_COUNT = (1 + 1 ) ,   TASK_TICK_MEMORY_SIZE = Max<size_t>(256U, STK_STACK_SIZE_MIN) ,   TASK_HANDLER_STACK_SIZE = Max<size_t>( 256 , STK_STACK_SIZE_MIN) }

Public Member Functions
	TimerHost ()
	~TimerHost ()
	Destructor.
void	Initialize (IKernel *kernel, EAccessMode mode)
	Initialize timer host instance.
bool	Start (Timer &timer, uint32_t delay, uint32_t period=0)
	Start timer.
bool	Stop (Timer &timer)
	Stop running timer.
bool	Reset (Timer &timer)
	Reset periodic timer's deadline.
bool	Restart (Timer &timer, uint32_t delay, uint32_t period=0)
	Atomically stop and re-start timer.
bool	StartOrReset (Timer &timer, uint32_t delay, uint32_t period=0)
	Start timer if inactive, or reset its deadline if already active and periodic.
bool	SetPeriod (Timer &timer, uint32_t period)
	Change the period of a running periodic timer without affecting its current deadline.
bool	IsEmpty () const
	Return true if no timers are currently active.
size_t	GetSize () const
	Return number of currently active timers.
bool	Shutdown ()
	Shutdown host instance. All timers are stopped and removed from the host.
Ticks	GetTimeNow () const
	Get current time.

Private Types
typedef void(*	TimerFuncType) (TimerHost *host)
	Timer task function prototype.
typedef StackMemoryDef< TASK_TICK_MEMORY_SIZE >::Type	TaskTickMemory
typedef StackMemoryDef< TASK_HANDLER_STACK_SIZE >::Type	TimerHostMemory
typedef sync::Pipe< Timer *, 32 >	ReadyQueue
typedef sync::Pipe< TimerCommand, 32 >	CommandQueue

Private Member Functions
	STK_NONCOPYABLE_CLASS (TimerHost)
void	UpdateTime ()
void	ProcessTimers ()
bool	ProcessCommands (Timeout next_sleep)
bool	PushCommand (TimerCommand cmd)

Private Attributes
TaskTickMemory	m_task_tick_memory
	tick task memory
TimerHostMemory	m_task_handler_memory [1]
	handler task memory
TimerWorkerTask	m_task_tick
	timer task
TimerWorkerTask	m_task_process [1]
	handler tasks
util::DListHead< Timer, false >	m_active
	active timers (tick task only)
ReadyQueue	m_queue
	queue of timers ready for handling
CommandQueue	m_commands
	command queue
Ticks	m_now
	last known current time (ticks)

Detailed Description

Software timer multiplexer that manages multiple Timer instances on top of a small fixed set of kernel tasks.

TimerHost internally runs two categories of tasks:

• One tick task that maintains the active timer list, evaluates deadlines every wake cycle, and queues expired timers for dispatch.
• One or more handler tasks (see STK_TIMER_THREADS_COUNT) that dequeue expired timers and invoke their OnExpired() callbacks.

All timers share the same tick and handler tasks, so the total kernel task overhead is constant regardless of how many timers are active.

Two timer modes are supported:

• One-shot: fires once after delay ticks and becomes inactive automatically.
• Periodic: fires every period ticks until explicitly stopped.

Note

TimerHost must be initialized before use by calling Initialize(). The maximum number of concurrently active timers is STK_TIMER_COUNT_MAX (default: 32). The maximum timer period is bounded by uint32_t (~49 days at 1 ms resolution).

// define a concrete timer by overriding OnExpired
class HeartbeatTimer : public stk::time::TimerHost::Timer
{
public:
    void OnExpired(stk::time::TimerHost *host)
    {
        // called every 500 ms
        ToggleLed();
    }
};
 
// declare host and timer instances (static storage, no heap)
stk::time::TimerHost  g_TimerHost;
HeartbeatTimer        g_Heartbeat;
 
// one-shot example: send a delayed notification
class NotifyTimer : public stk::time::TimerHost::Timer
{
public:
    void OnExpired(stk::time::TimerHost *host)
    {
        g_Event.Signal();
    }
};
 
NotifyTimer g_Notify;
 
void SetupTimers(stk::IKernel *kernel)
{
    // initialize the host, must be called before Start()
    g_TimerHost.Initialize(kernel, stk::ACCESS_USER);
 
    // start 500 ms periodic heartbeat
    uint32_t period = stk::GetTicksFromMsec(500);
    g_TimerHost.Start(g_Heartbeat, period, period);
 
    // start a one-shot notification after 1 second
    uint32_t delay = stk::GetTicksFromMsec(1000);
    g_TimerHost.Start(g_Notify, delay);
}

See also

TimerHost::Timer, STK_TIMER_THREADS_COUNT, STK_TIMER_HANDLER_STACK_SIZE, STK_TIMER_COUNT_MAX

Definition at line 111 of file stk_time_timer.h.

Member Typedef Documentation

CommandQueue

typedef sync::Pipe<TimerCommand, 32 > stk::time::TimerHost::CommandQueue

private

Definition at line 355 of file stk_time_timer.h.

ReadyQueue

typedef sync::Pipe<Timer *, 32 > stk::time::TimerHost::ReadyQueue

private

Definition at line 354 of file stk_time_timer.h.

TaskTickMemory

typedef StackMemoryDef<TASK_TICK_MEMORY_SIZE>::Type stk::time::TimerHost::TaskTickMemory

private

Definition at line 352 of file stk_time_timer.h.

TimerFuncType

typedef void(* stk::time::TimerHost::TimerFuncType) (TimerHost *host)

private

Timer task function prototype.

Definition at line 279 of file stk_time_timer.h.

TimerHostMemory

typedef StackMemoryDef<TASK_HANDLER_STACK_SIZE>::Type stk::time::TimerHost::TimerHostMemory

private

Definition at line 353 of file stk_time_timer.h.

Member Enumeration Documentation

EConsts

enum stk::time::TimerHost::EConsts

Enumerator
TASK_COUNT	total number of tasks serving this instance stack memory size of the tick task
TASK_TICK_MEMORY_SIZE	stack memory size of the timer handler task
TASK_HANDLER_STACK_SIZE

Definition at line 114 of file stk_time_timer.h.

    {
        TASK_COUNT = (1 + STK_TIMER_THREADS_COUNT),

        TASK_TICK_MEMORY_SIZE = Max<size_t>(256U, STK_STACK_SIZE_MIN),

        TASK_HANDLER_STACK_SIZE = Max<size_t>(STK_TIMER_HANDLER_STACK_SIZE, STK_STACK_SIZE_MIN)
    };

Constructor & Destructor Documentation

TimerHost()

stk::time::TimerHost::TimerHost ( )

inlineexplicit

Definition at line 176 of file stk_time_timer.h.

        : m_task_tick_memory(), m_task_handler_memory(), m_task_tick(), m_task_process(), m_active(), m_now(0)
    {}

References m_active, m_now, m_task_handler_memory, m_task_process, m_task_tick, and m_task_tick_memory.

Referenced by Initialize(), stk::time::TimerHost::TimerWorkerTask::Initialize(), and STK_NONCOPYABLE_CLASS().

Here is the caller graph for this function:

~TimerHost()

stk::time::TimerHost::~TimerHost ( )

inline

Destructor.

Note

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

Definition at line 183 of file stk_time_timer.h.

    {}

Member Function Documentation

GetSize()

size_t stk::time::TimerHost::GetSize ( ) const

inline

Return number of currently active timers.

Returns

Active timer count.

Note

The value is advisory and may change immediately after the call.

Definition at line 261 of file stk_time_timer.h.

{ return m_active.GetSize(); }

References m_active.

Referenced by stk_timerhost_get_size().

Here is the caller graph for this function:

GetTimeNow()

Ticks stk::time::TimerHost::GetTimeNow ( ) const

inline

Get current time.

Returns

Current time (ticks).

Definition at line 271 of file stk_time_timer.h.

{ return hw::ReadVolatile64(&m_now); }

References m_now, and stk::hw::ReadVolatile64().

Referenced by stk_timerhost_get_time_now().

Here is the call graph for this function:

Here is the caller graph for this function:

Initialize()

void stk::time::TimerHost::Initialize ( IKernel * kernel, EAccessMode mode )

inline

Initialize timer host instance.

Parameters

[in]	kernel	Kernel to which instance will be bound.
[in]	mode	Access mode for the timer handling tasks which call expired timers.

Definition at line 387 of file stk_time_timer.h.

{
    for (int32_t i = 0; i < STK_TIMER_THREADS_COUNT; ++i)
    {
        m_task_process[i].Initialize(this, m_task_handler_memory[i], TASK_HANDLER_STACK_SIZE, mode, [](TimerHost *host) {
            host->ProcessTimers();
        });
        kernel->AddTask(&m_task_process[i]);
    }
 
    m_task_tick.Initialize(this, m_task_tick_memory, TASK_TICK_MEMORY_SIZE, ACCESS_USER, [](TimerHost *host) {
        host->UpdateTime();
    });
    kernel->AddTask(&m_task_tick);
}

References stk::ACCESS_USER, stk::IKernel::AddTask(), m_task_handler_memory, m_task_process, m_task_tick, m_task_tick_memory, ProcessTimers(), STK_TIMER_THREADS_COUNT, TASK_HANDLER_STACK_SIZE, TASK_TICK_MEMORY_SIZE, TimerHost(), and UpdateTime().

Referenced by stk_timerhost_init().

Here is the call graph for this function:

Here is the caller graph for this function:

IsEmpty()

bool stk::time::TimerHost::IsEmpty ( ) const

inline

Return true if no timers are currently active.

Returns

True if active timer count is zero.

Note

The value is advisory and may change immediately after the call.

Definition at line 255 of file stk_time_timer.h.

{ return m_active.IsEmpty(); }

References m_active.

Referenced by stk_timerhost_is_empty().

Here is the caller graph for this function:

ProcessCommands()

bool stk::time::TimerHost::ProcessCommands ( Timeout next_sleep )

inlineprivate

Definition at line 653 of file stk_time_timer.h.

{
    // if nothing is active, sleep indefinitely until a command arrives
    next_sleep = (m_active.IsEmpty() ? WAIT_INFINITE : next_sleep);
 
    TimerCommand cmd;
    while (m_commands.Read(cmd, next_sleep))
    {
        switch (cmd.cmd)
        {
        case TimerCommand::CMD_START: {
            Timer *timer = cmd.timer;
            STK_ASSERT(timer != nullptr);
 
            // reject if already active or linked (double-start)
            if (timer->m_active)
                continue;
 
            STK_ASSERT(!timer->IsLinked());
 
            timer->m_deadline = cmd.timestamp + cmd.delay;
            timer->m_period   = cmd.period;
            timer->m_active   = true;
            timer->m_pending  = false;
 
            m_active.LinkBack(timer);
            next_sleep = NO_WAIT;
            break; }
 
        case TimerCommand::CMD_STOP: {
            Timer *timer = cmd.timer;
            STK_ASSERT(timer != nullptr);
 
            timer->m_active  = false;
            timer->m_pending = false;
 
            // allow possibly duplicate CMD_STOP as it is harmless for the logic
            if (timer->IsLinked())
                m_active.Unlink(timer);
            break; }
 
        case TimerCommand::CMD_RESET: {
            Timer *timer = cmd.timer;
            STK_ASSERT(timer != nullptr);
 
            // only reset if still active and periodic
            if (!timer->m_active || (timer->m_period == 0))
                continue;
 
            STK_ASSERT(timer->GetHead() == &m_active);
 
            timer->m_deadline = cmd.timestamp + timer->m_period;
            timer->m_pending  = false;
 
            next_sleep = NO_WAIT;
            break; }
 
        case TimerCommand::CMD_RESTART: {
            // atomic stop + re-start: no precondition on current timer state
            Timer *timer = cmd.timer;
            STK_ASSERT(timer != nullptr);
 
            // unlink if currently in the active list
            if (timer->IsLinked())
                m_active.Unlink(timer);
 
            // re-arm with fresh parameters
            timer->m_deadline = cmd.timestamp + cmd.delay;
            timer->m_period   = cmd.period;
            timer->m_active   = true;
            timer->m_pending  = false;
 
            // re-link to the back of the list
            m_active.LinkBack(timer);
            next_sleep = NO_WAIT;
            break; }
 
        case TimerCommand::CMD_START_OR_RESET: {
            Timer *timer = cmd.timer;
            STK_ASSERT(timer != nullptr);
 
            // not currently active: start with supplied parameters
            if (!timer->m_active)
            {
                STK_ASSERT(!timer->IsLinked());
 
                timer->m_deadline = cmd.timestamp + cmd.delay;
                timer->m_period   = cmd.period;
                timer->m_active   = true;
                timer->m_pending  = false;
 
                m_active.LinkBack(timer);
            }
            else
            // active and periodic: reset deadline anchored to call-site timestamp
            if (timer->m_period != 0)
            {
                STK_ASSERT(timer->GetHead() == &m_active);
 
                timer->m_deadline = cmd.timestamp + timer->m_period;
                timer->m_pending  = false;
            }
 
            // active one-shot: no action — cannot reset a one-shot mid-flight,
            // caller should use Restart() if unconditional re-arm is needed.
 
            next_sleep = NO_WAIT;
            break; }
 
        case TimerCommand::CMD_SET_PERIOD: {
            Timer *timer = cmd.timer;
            STK_ASSERT(timer != nullptr);
            STK_ASSERT(cmd.period != 0U);
 
            // guard: only apply if still active and periodic
            if (!timer->m_active || (timer->m_period == 0U))
                continue;
 
            STK_ASSERT(timer->GetHead() == &m_active);
 
            // new period takes effect on the next reload, current deadline is
            // intentionally left unchanged so the in-flight interval is not
            // truncated or extended, caller can follow up with Reset() if
            // immediate application is required
            timer->m_period = cmd.period;
            break; }
 
        case TimerCommand::CMD_SHUTDOWN: {
            // wake all handler tasks with shutdown sentinels
            for (int32_t i = 0; i < STK_TIMER_THREADS_COUNT; ++i)
                m_queue.Write(nullptr, NO_WAIT);
 
            // signal UpdateTime() to exit its loop
            return false; }
 
        default: {
            STK_ASSERT(false);
            break; }
        }
    }
 
    return true;
}

References stk::time::TimerHost::TimerCommand::cmd, stk::time::TimerHost::TimerCommand::CMD_RESET, stk::time::TimerHost::TimerCommand::CMD_RESTART, stk::time::TimerHost::TimerCommand::CMD_SET_PERIOD, stk::time::TimerHost::TimerCommand::CMD_SHUTDOWN, stk::time::TimerHost::TimerCommand::CMD_START, stk::time::TimerHost::TimerCommand::CMD_START_OR_RESET, stk::time::TimerHost::TimerCommand::CMD_STOP, stk::time::TimerHost::TimerCommand::delay, stk::util::DListEntry< T, _ClosedLoop >::GetHead(), stk::util::DListEntry< T, _ClosedLoop >::IsLinked(), m_active, stk::time::TimerHost::Timer::m_active, m_commands, stk::time::TimerHost::Timer::m_deadline, stk::time::TimerHost::Timer::m_pending, stk::time::TimerHost::Timer::m_period, m_queue, stk::NO_WAIT, stk::time::TimerHost::TimerCommand::period, STK_ASSERT, STK_TIMER_THREADS_COUNT, stk::time::TimerHost::TimerCommand::timer, stk::time::TimerHost::TimerCommand::timestamp, and stk::WAIT_INFINITE.

Referenced by UpdateTime().

Here is the call graph for this function:

Here is the caller graph for this function:

ProcessTimers()

void stk::time::TimerHost::ProcessTimers ( )

inlineprivate

Definition at line 632 of file stk_time_timer.h.

{
    Timer *timer;
    while (m_queue.Read(timer))
    {
        // nullptr is the shutdown sentinel pushed by CMD_SHUTDOWN
        if (timer == nullptr)
            break;
 
        if (timer->m_pending)
        {
            timer->m_pending = false;
            timer->OnExpired(this);
        }
    }
}

References stk::time::TimerHost::Timer::m_pending, m_queue, and stk::time::TimerHost::Timer::OnExpired().

Referenced by Initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

PushCommand()

bool stk::time::TimerHost::PushCommand ( TimerCommand cmd )

inlineprivate

Definition at line 801 of file stk_time_timer.h.

{
    if (!m_commands.Write(cmd, NO_WAIT))
    {
        // queue full: this indicates a usage error — more commands are being
        // issued than the tick task can drain. Loud in debug, recoverable in
        // release (caller receives false and can retry or escalate).
        STK_ASSERT(false);
        return false;
    }
 
    return true;
}

References m_commands, stk::NO_WAIT, and STK_ASSERT.

Referenced by Reset(), Restart(), SetPeriod(), Shutdown(), Start(), StartOrReset(), and Stop().

Here is the caller graph for this function:

Reset()

bool stk::time::TimerHost::Reset ( Timer & timer )

inline

Reset periodic timer's deadline.

Parameters

[in]

timer

Timer instance. Must be active and periodic.

Returns

True on success, false if timer is not active, not periodic, or command queue is full.

Definition at line 448 of file stk_time_timer.h.

{
    // timer must be active and periodic
    if (!timer.m_active || (timer.m_period == 0))
        return false;
 
    return PushCommand({
        .cmd      = TimerCommand::CMD_RESET,
        .timer     = &timer,
        .timestamp = GetTicks(),
        .delay     = 0U,
        .period    = 0U
    });
}

References stk::time::TimerHost::TimerCommand::CMD_RESET, stk::GetTicks(), stk::time::TimerHost::Timer::m_active, stk::time::TimerHost::Timer::m_period, and PushCommand().

Referenced by stk_timer_reset().

Here is the call graph for this function:

Here is the caller graph for this function:

Restart()

bool stk::time::TimerHost::Restart ( Timer & timer, uint32_t delay, uint32_t period = 0 )

inline

Atomically stop and re-start timer.

Parameters

[in]	timer	Timer instance (active or inactive).
[in]	delay	Initial delay in ticks before first expiration.
[in]	period	Reload period in ticks (0 is one-shot timer).

Returns

True on success, false if command queue is full.

Note

Unlike calling Stop() followed by Start(), this operation is atomic with respect to the tick task: the timer cannot fire between the implicit stop and re-start, and only one command queue slot is consumed. Useful for watchdog refresh and debounce reset patterns. Safe to call regardless of whether the timer is currently active.

Definition at line 467 of file stk_time_timer.h.

{
    STK_ASSERT(delay <= static_cast<uint32_t>(WAIT_INFINITE));
    STK_ASSERT((period == 0U) || (period <= static_cast<uint32_t>(WAIT_INFINITE)));
 
    return PushCommand({
        .cmd       = TimerCommand::CMD_RESTART,
        .timer     = &timer,
        .timestamp = GetTicks(),
        .delay     = delay,
        .period    = period
    });
}

References stk::time::TimerHost::TimerCommand::CMD_RESTART, stk::GetTicks(), PushCommand(), STK_ASSERT, and stk::WAIT_INFINITE.

Referenced by stk_timer_restart().

Here is the call graph for this function:

Here is the caller graph for this function:

SetPeriod()

bool stk::time::TimerHost::SetPeriod ( Timer & timer, uint32_t period )

inline

Change the period of a running periodic timer without affecting its current deadline.

Parameters

[in]	timer	Timer instance. Must be active and periodic.
[in]	period	New reload period in ticks. Must be non-zero.

Returns

True on success, false if timer is not active, not periodic, period is zero, or command queue is full.

Note

The new period takes effect on the next reload after the current deadline fires. To apply the new period immediately (restart from now), call Reset() after SetPeriod().

Definition at line 503 of file stk_time_timer.h.

{
    // period == 0 is rejected: it would silently convert a periodic timer
    // to one-shot semantics, which is better expressed via Stop() + Start()
    if (!timer.m_active || (timer.m_period == 0U) || (period == 0U) ||
        (period > static_cast<uint32_t>(WAIT_INFINITE)))
    {
        return false;
    }
 
    return PushCommand({
        .cmd       = TimerCommand::CMD_SET_PERIOD,
        .timer     = &timer,
        .timestamp = 0,
        .delay     = 0U,
        .period    = period
    });
}

References stk::time::TimerHost::TimerCommand::CMD_SET_PERIOD, stk::time::TimerHost::Timer::m_active, stk::time::TimerHost::Timer::m_period, PushCommand(), and stk::WAIT_INFINITE.

Referenced by stk_timer_set_period().

Here is the call graph for this function:

Here is the caller graph for this function:

Shutdown()

bool stk::time::TimerHost::Shutdown ( )

inline

Shutdown host instance. All timers are stopped and removed from the host.

Returns

True on success, false if command queue is full.

Definition at line 526 of file stk_time_timer.h.

{
    return PushCommand({
        .cmd       = TimerCommand::CMD_SHUTDOWN,
        .timer     = nullptr,
        .timestamp = 0,
        .delay     = 0U,
        .period    = 0U
    });
}

References stk::time::TimerHost::TimerCommand::CMD_SHUTDOWN, and PushCommand().

Referenced by stk_timerhost_shutdown().

Here is the call graph for this function:

Here is the caller graph for this function:

Start()

bool stk::time::TimerHost::Start ( Timer & timer, uint32_t delay, uint32_t period = 0 )

inline

Start timer.

Parameters

[in]	timer	Timer instance. Must not already be active.
[in]	delay	Initial delay in ticks before first expiration.
[in]	period	Reload period in ticks (0 is one-shot timer).

Returns

True on success, false if timer is already active or command queue is full.

Definition at line 407 of file stk_time_timer.h.

{
    STK_ASSERT(delay <= static_cast<uint32_t>(WAIT_INFINITE));
    STK_ASSERT((period == 0U) || (period <= static_cast<uint32_t>(WAIT_INFINITE)));
 
    // timer must not already be active
    if (timer.m_active)
        return false;
 
    return PushCommand({
        .cmd       = TimerCommand::CMD_START,
        .timer     = &timer,
        .timestamp = GetTicks(),
        .delay     = delay,
        .period    = period
    });
}

References stk::time::TimerHost::TimerCommand::CMD_START, stk::GetTicks(), stk::time::TimerHost::Timer::m_active, PushCommand(), STK_ASSERT, and stk::WAIT_INFINITE.

Referenced by stk_timer_start().

Here is the call graph for this function:

Here is the caller graph for this function:

StartOrReset()

bool stk::time::TimerHost::StartOrReset ( Timer & timer, uint32_t delay, uint32_t period = 0 )

inline

Start timer if inactive, or reset its deadline if already active and periodic.

Parameters

[in]	timer	Timer instance (active or inactive).
[in]	delay	Initial delay in ticks (used only when starting).
[in]	period	Reload period in ticks (used only when starting, 0 is one-shot).

Returns

True on success, false if command queue is full.

Note

Collapses the common pattern: if (timer.IsActive()) host.Reset(timer); else host.Start(timer, delay, period); into a single atomic operation, eliminating the TOCTOU race between the IsActive() check and the subsequent call. If the timer is active but one-shot, no action is taken (a one-shot timer mid-flight cannot be reset; use Restart() instead).

Definition at line 485 of file stk_time_timer.h.

{
    STK_ASSERT(delay <= static_cast<uint32_t>(WAIT_INFINITE));
    STK_ASSERT((period == 0U) || (period <= static_cast<uint32_t>(WAIT_INFINITE)));
 
    return PushCommand({
        .cmd       = TimerCommand::CMD_START_OR_RESET,
        .timer     = &timer,
        .timestamp = GetTicks(),
        .delay     = delay,
        .period    = period
    });
}

References stk::time::TimerHost::TimerCommand::CMD_START_OR_RESET, stk::GetTicks(), PushCommand(), STK_ASSERT, and stk::WAIT_INFINITE.

Referenced by stk_timer_start_or_reset().

Here is the call graph for this function:

Here is the caller graph for this function:

STK_NONCOPYABLE_CLASS()

stk::time::TimerHost::STK_NONCOPYABLE_CLASS ( TimerHost )

private

References TimerHost().

Here is the call graph for this function:

Stop()

bool stk::time::TimerHost::Stop ( Timer & timer )

inline

Stop running timer.

Parameters

[in]

timer

Timer instance. Must be active.

Returns

True on success, false if timer is not active or command queue is full.

Definition at line 429 of file stk_time_timer.h.

{
    // timer must be active
    if (!timer.m_active)
        return false;
 
    return PushCommand({
        .cmd       = TimerCommand::CMD_STOP,
        .timer     = &timer,
        .timestamp = 0,
        .delay     = 0U,
        .period    = 0U
    });
}

References stk::time::TimerHost::TimerCommand::CMD_STOP, stk::time::TimerHost::Timer::m_active, and PushCommand().

Referenced by stk_timer_stop().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateTime()

void stk::time::TimerHost::UpdateTime ( )

inlineprivate

Definition at line 541 of file stk_time_timer.h.

{
    Timeout next_sleep = NO_WAIT;
 
    while (ProcessCommands(next_sleep))
    {
        next_sleep = WAIT_INFINITE;
 
        Ticks now = GetTicks();
 
        // using WriteVolatile64() to guarantee correct lockless reading order by ReadVolatile64
        hw::WriteVolatile64(&m_now, now);
 
        Timer *timer = static_cast<Timer *>(m_active.GetFirst());
        while (timer != nullptr)
        {
            Timer *next = static_cast<Timer *>(timer->GetNext());
 
            if (timer->m_active)
            {
                // check if still pending to be handled
                if (timer->m_pending)
                {
                    timer = next;
                    continue;
                }
 
                bool one_shot = false;
                Ticks diff = now - timer->m_deadline;
 
                if (diff >= 0)
                {
                    // set timestamp at which timer expired
                    timer->m_timestamp = now;
 
                    // avoid updating timer again before it was handled
                    timer->m_pending = true;
 
                    // periodic
                    if (timer->m_period != 0)
                    {
                        // reload (use now to avoid drift accumulation)
                        timer->m_deadline = now + static_cast<Ticks>(timer->m_period) - diff;
                    }
                    // one-shot
                    else
                    {
                        one_shot = true;
 
                        // remove from active timers
                        m_active.Unlink(timer);
 
                        // mark as inactive (must follow Unlink)
                        timer->m_active = false;
                    }
 
                    __stk_full_memfence();
 
                    // push to the handling queue
                    m_queue.Write(timer);
                }
 
                // one-shot timer does not affect next_sleep
                if (!one_shot)
                {
                    Timeout next_deadline = static_cast<Timeout>(timer->m_deadline - now);
                    STK_ASSERT(next_deadline > 0);
 
                    if ((next_deadline > 0) && (next_deadline < next_sleep))
                        next_sleep = next_deadline;
                }
            }
            else
            {
                // could be stopped externally, remove from active timers
                m_active.Unlink(timer);
            }
 
            timer = next;
        }
    }
 
    // unlink all timers on shutdown
    while (Timer::DLEntryType *timer = m_active.GetFirst())
        m_active.Unlink(timer);
}

References stk::util::DListEntry< T, _ClosedLoop >::GetNext(), stk::GetTicks(), m_active, stk::time::TimerHost::Timer::m_active, stk::time::TimerHost::Timer::m_deadline, m_now, stk::time::TimerHost::Timer::m_pending, stk::time::TimerHost::Timer::m_period, m_queue, stk::time::TimerHost::Timer::m_timestamp, stk::NO_WAIT, ProcessCommands(), STK_ASSERT, stk::WAIT_INFINITE, and stk::hw::WriteVolatile64().

Referenced by Initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_active

util::DListHead<Timer, false> stk::time::TimerHost::m_active

private

active timers (tick task only)

Definition at line 361 of file stk_time_timer.h.

Referenced by GetSize(), IsEmpty(), ProcessCommands(), TimerHost(), and UpdateTime().

m_commands

CommandQueue stk::time::TimerHost::m_commands

private

command queue

Definition at line 363 of file stk_time_timer.h.

Referenced by ProcessCommands(), and PushCommand().

m_now

Ticks stk::time::TimerHost::m_now

private

last known current time (ticks)

Definition at line 364 of file stk_time_timer.h.

Referenced by GetTimeNow(), TimerHost(), and UpdateTime().

m_queue

ReadyQueue stk::time::TimerHost::m_queue

private

queue of timers ready for handling

Definition at line 362 of file stk_time_timer.h.

Referenced by ProcessCommands(), ProcessTimers(), and UpdateTime().

m_task_handler_memory

TimerHostMemory stk::time::TimerHost::m_task_handler_memory[1]

private

handler task memory

Definition at line 358 of file stk_time_timer.h.

Referenced by Initialize(), and TimerHost().

m_task_process

TimerWorkerTask stk::time::TimerHost::m_task_process[1]

private

handler tasks

Definition at line 360 of file stk_time_timer.h.

Referenced by Initialize(), and TimerHost().

m_task_tick

TimerWorkerTask stk::time::TimerHost::m_task_tick

private

timer task

Definition at line 359 of file stk_time_timer.h.

Referenced by Initialize(), and TimerHost().

m_task_tick_memory

TaskTickMemory stk::time::TimerHost::m_task_tick_memory

private

tick task memory

Definition at line 357 of file stk_time_timer.h.

Referenced by Initialize(), and TimerHost().

---

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

• stk_time_timer.h