anonymous_namespace{threadx_stk.cpp} Namespace Reference

Classes
class	StkThread
class	ScopedWaitKind
class	StkBytePool
class	StkTimerThread

Functions
__stk_forceinline bool	InIsr ()
__stk_forceinline bool	KernelRunning ()
__stk_forceinline bool	KernelInitialized ()
__stk_forceinline stk::Timeout	ToStkTimeout (ULONG wait_option)
__stk_forceinline stk::Weight	ToStkWeight (UINT priority, UINT threshold)
__stk_forceinline UINT	WaitResultToTx (stk::EWaitResult wr, UINT timeout_status)
__stk_forceinline StkThread *	ThreadOf (TX_THREAD *tx)
__stk_forceinline bool	IsValidThread (const TX_THREAD *tx)
StkThread *	CurrentThread ()
TX_THREAD *	ThreadFromTid (stk::TId tid)
static void	FillSuspended (const stk::ISyncObject &sobj, TX_THREAD **first_suspended, ULONG *suspended_count)
static void	FillSuspended (const stk::sync::EventFlags &wf, TX_THREAD **first_suspended, ULONG *suspended_count)
__stk_forceinline bool	CanBlock (ULONG wait_option)
UINT	ThreadStateOf (TX_THREAD *tx)
UINT	RegisterThread (StkThread *th)
bool	WaitThreadRemoved (const StkThread *th)
__stk_forceinline stk::sync::Mutex *	MutexOf (TX_MUTEX *m)
__stk_forceinline bool	IsValidMutex (const TX_MUTEX *m)
__stk_forceinline stk::sync::Semaphore *	SemOf (TX_SEMAPHORE *s)
__stk_forceinline bool	IsValidSem (const TX_SEMAPHORE *s)
__stk_forceinline stk::sync::EventFlags *	EfOf (TX_EVENT_FLAGS_GROUP *g)
__stk_forceinline bool	IsValidEf (const TX_EVENT_FLAGS_GROUP *g)
__stk_forceinline stk::sync::MessageQueue *	QueueOf (TX_QUEUE *q)
__stk_forceinline bool	IsValidQueue (const TX_QUEUE *q)
UINT	QueueSend (TX_QUEUE *queue_ptr, void *source_ptr, ULONG wait_option, bool front)
__stk_forceinline stk::memory::BlockMemoryPool *	BlockPoolOf (TX_BLOCK_POOL *p)
__stk_forceinline bool	IsValidBlockPool (const TX_BLOCK_POOL *p)
__stk_forceinline StkBytePool *	BytePoolOf (TX_BYTE_POOL *p)
__stk_forceinline bool	IsValidBytePool (const TX_BYTE_POOL *p)
void	BytePoolLink (StkBytePool *p)
void	BytePoolUnlink (StkBytePool *p)
StkBytePool *	BytePoolFind (const void *mem)
void	TimerListRemove (TX_TIMER *t)
bool	TimerListInsert (TX_TIMER *t)
UINT	EnsureTimerThread ()
__stk_forceinline bool	IsValidTimer (const TX_TIMER *t)

Variables
stk::TId	g_TimerTid = stk::TID_NONE
volatile bool	g_IntDisabled = false
int64_t	g_TimeOffset = 0
const size_t	BLOCK_HDR_SIZE = sizeof(void *)
StkBytePool *	g_BytePools = nullptr
StkTimerThread	g_TimerThread
stk::sync::Event	g_TimerEvent (false, false)
TX_TIMER *	g_TimerHead = nullptr

Function Documentation

BlockPoolOf()

__stk_forceinline stk::memory::BlockMemoryPool * anonymous_namespace{threadx_stk.cpp}::BlockPoolOf

(

TX_BLOCK_POOL *

p

)

Definition at line 1938 of file threadx_stk.cpp.

{
    return static_cast<stk::memory::BlockMemoryPool *>(static_cast<void *>(p->tx_block_pool_stk_storage));
}

References __stk_forceinline, BlockPoolOf(), and TX_BLOCK_POOL_STRUCT::tx_block_pool_stk_storage.

Referenced by BlockPoolOf().

Here is the call graph for this function:

Here is the caller graph for this function:

BytePoolFind()

StkBytePool * anonymous_namespace{threadx_stk.cpp}::BytePoolFind

(

const void *

mem

)

Definition at line 2217 of file threadx_stk.cpp.

{
    StkBytePool *p = g_BytePools;
 
    while ((p != nullptr) && !p->Contains(mem))
    {
        p = p->m_next;
    }
 
    return p;
}

References BytePoolFind(), anonymous_namespace{threadx_stk.cpp}::StkBytePool::Contains(), g_BytePools, and anonymous_namespace{threadx_stk.cpp}::StkBytePool::m_next.

Referenced by BytePoolFind().

Here is the call graph for this function:

Here is the caller graph for this function:

BytePoolLink()

void anonymous_namespace{threadx_stk.cpp}::BytePoolLink

(

StkBytePool *

p

)

Definition at line 2192 of file threadx_stk.cpp.

{
    p->m_next   = g_BytePools;
    g_BytePools = p;
}

References BytePoolLink(), g_BytePools, and anonymous_namespace{threadx_stk.cpp}::StkBytePool::m_next.

Referenced by BytePoolLink().

Here is the call graph for this function:

Here is the caller graph for this function:

BytePoolOf()

__stk_forceinline StkBytePool * anonymous_namespace{threadx_stk.cpp}::BytePoolOf

(

TX_BYTE_POOL *

p

)

Definition at line 2182 of file threadx_stk.cpp.

{
    return static_cast<StkBytePool *>(static_cast<void *>(p->tx_byte_pool_stk_storage));
}

References __stk_forceinline, BytePoolOf(), and TX_BYTE_POOL_STRUCT::tx_byte_pool_stk_storage.

Referenced by BytePoolOf().

Here is the call graph for this function:

Here is the caller graph for this function:

BytePoolUnlink()

void anonymous_namespace{threadx_stk.cpp}::BytePoolUnlink

(

StkBytePool *

p

)

Definition at line 2199 of file threadx_stk.cpp.

{
    StkBytePool **link = &g_BytePools;
 
    while ((*link != nullptr) && (*link != p))
    {
        link = &((*link)->m_next);
    }
 
    if (*link != nullptr)
    {
        *link = p->m_next;
    }
 
    p->m_next = nullptr;
}

References BytePoolUnlink(), g_BytePools, and anonymous_namespace{threadx_stk.cpp}::StkBytePool::m_next.

Referenced by BytePoolUnlink().

Here is the call graph for this function:

Here is the caller graph for this function:

CanBlock()

__stk_forceinline bool anonymous_namespace{threadx_stk.cpp}::CanBlock

(

ULONG

wait_option

)

Definition at line 291 of file threadx_stk.cpp.

{
    return ((wait_option == TX_NO_WAIT) || (CurrentThread() != nullptr));
}

References __stk_forceinline, CanBlock(), CurrentThread(), and TX_NO_WAIT.

Referenced by CanBlock(), and QueueSend().

Here is the call graph for this function:

Here is the caller graph for this function:

CurrentThread()

StkThread * anonymous_namespace{threadx_stk.cpp}::CurrentThread

(

)

Definition at line 224 of file threadx_stk.cpp.

{
    StkThread *th = nullptr;
 
    if (!InIsr() && KernelRunning())
    {
        const stk::TId tid = stk::GetTid();
 
        if ((tid != stk::TID_NONE) && (tid != g_TimerTid))
        {
            th = static_cast<StkThread *>(stk::GetUserTaskFromTid(tid));
        }
    }
 
    return th;
}

References CurrentThread(), g_TimerTid, stk::GetTid(), stk::GetUserTaskFromTid(), InIsr(), KernelRunning(), and stk::TID_NONE.

Referenced by CanBlock(), CurrentThread(), and anonymous_namespace{threadx_stk.cpp}::ScopedWaitKind::ScopedWaitKind().

Here is the call graph for this function:

Here is the caller graph for this function:

EfOf()

__stk_forceinline stk::sync::EventFlags * anonymous_namespace{threadx_stk.cpp}::EfOf

(

TX_EVENT_FLAGS_GROUP *

g

)

Definition at line 1473 of file threadx_stk.cpp.

{
    return static_cast<stk::sync::EventFlags *>(static_cast<void *>(g->tx_event_flags_group_stk_storage));
}

References __stk_forceinline, EfOf(), and TX_EVENT_FLAGS_GROUP_STRUCT::tx_event_flags_group_stk_storage.

Referenced by EfOf().

Here is the call graph for this function:

Here is the caller graph for this function:

EnsureTimerThread()

UINT anonymous_namespace{threadx_stk.cpp}::EnsureTimerThread

(

)

Definition at line 2592 of file threadx_stk.cpp.

{
    UINT result = TX_SUCCESS;
 
    if (!g_TimerThread.m_started)
    {
        if (g_StkKernel.GetSwitchStrategy()->GetSize() >= static_cast<size_t>(TX_STK_MAX_THREADS + 1U))
        {
            result = TX_NO_MEMORY;
        }
        else
        {
            g_TimerThread.m_started = true;
            g_TimerTid = stk::GetTidFromUserTask(&g_TimerThread);
 
            g_StkKernel.AddTask(&g_TimerThread);
        }
    }
 
    return result;
}

References EnsureTimerThread(), g_StkKernel, g_TimerThread, g_TimerTid, stk::GetTidFromUserTask(), TX_NO_MEMORY, TX_STK_MAX_THREADS, and TX_SUCCESS.

Referenced by EnsureTimerThread().

Here is the call graph for this function:

Here is the caller graph for this function:

FillSuspended() [1/2]

void anonymous_namespace{threadx_stk.cpp}::FillSuspended ( const stk::ISyncObject & sobj, TX_THREAD ** first_suspended, ULONG * suspended_count )

static

Definition at line 256 of file threadx_stk.cpp.

{
    size_t   count = 0U;
    stk::TId first = stk::TID_NONE;
 
    {
        const stk::sync::ScopedCriticalSection cs_;
 
        count = sobj.GetWaitList().GetSize();
        first = sobj.GetFirstWaiterTid();
    }
 
    if (suspended_count != nullptr) { *suspended_count = static_cast<ULONG>(count); }
    if (first_suspended != nullptr) { *first_suspended = ThreadFromTid(first); } // TID_NONE -> nullptr
}

References FillSuspended(), stk::ISyncObject::GetFirstWaiterTid(), stk::util::DListHead< T, TClosedLoop >::GetSize(), stk::ISyncObject::GetWaitList(), ThreadFromTid(), and stk::TID_NONE.

Referenced by FillSuspended(), and FillSuspended().

Here is the call graph for this function:

Here is the caller graph for this function:

FillSuspended() [2/2]

void anonymous_namespace{threadx_stk.cpp}::FillSuspended ( const stk::sync::EventFlags & wf, TX_THREAD ** first_suspended, ULONG * suspended_count )

static

Definition at line 274 of file threadx_stk.cpp.

{
    size_t   count = 0U;
    stk::TId first = stk::TID_NONE;
 
    {
        const stk::sync::ScopedCriticalSection cs_;
 
        count = wf.GetWaitList().GetSize();
        first = wf.GetFirstWaiterTid();
    }
 
    if (suspended_count != nullptr) { *suspended_count = static_cast<ULONG>(count); }
    if (first_suspended != nullptr) { *first_suspended = ThreadFromTid(first); } // TID_NONE -> nullptr
}

References FillSuspended(), stk::sync::EventFlags::GetFirstWaiterTid(), stk::util::DListHead< T, TClosedLoop >::GetSize(), stk::sync::EventFlags::GetWaitList(), ThreadFromTid(), and stk::TID_NONE.

Here is the call graph for this function:

InIsr()

__stk_forceinline bool anonymous_namespace{threadx_stk.cpp}::InIsr

(

)

Definition at line 63 of file threadx_stk.cpp.

{
    return stk::hw::IsInsideISR();
}

References __stk_forceinline, InIsr(), and stk::hw::IsInsideISR().

Referenced by CurrentThread(), InIsr(), and WaitThreadRemoved().

Here is the call graph for this function:

Here is the caller graph for this function:

IsValidBlockPool()

__stk_forceinline bool anonymous_namespace{threadx_stk.cpp}::IsValidBlockPool

(

const TX_BLOCK_POOL *

p

)

Definition at line 1942 of file threadx_stk.cpp.

{
    return ((p != nullptr) && (p->tx_block_pool_id == TX_BLOCK_POOL_ID));
}

References __stk_forceinline, IsValidBlockPool(), TX_BLOCK_POOL_ID, and TX_BLOCK_POOL_STRUCT::tx_block_pool_id.

Referenced by IsValidBlockPool().

Here is the call graph for this function:

Here is the caller graph for this function:

IsValidBytePool()

__stk_forceinline bool anonymous_namespace{threadx_stk.cpp}::IsValidBytePool

(

const TX_BYTE_POOL *

p

)

Definition at line 2186 of file threadx_stk.cpp.

{
    return ((p != nullptr) && (p->tx_byte_pool_id == TX_BYTE_POOL_ID));
}

References __stk_forceinline, IsValidBytePool(), TX_BYTE_POOL_ID, and TX_BYTE_POOL_STRUCT::tx_byte_pool_id.

Referenced by IsValidBytePool().

Here is the call graph for this function:

Here is the caller graph for this function:

IsValidEf()

__stk_forceinline bool anonymous_namespace{threadx_stk.cpp}::IsValidEf

(

const TX_EVENT_FLAGS_GROUP *

g

)

Definition at line 1477 of file threadx_stk.cpp.

{
    return ((g != nullptr) && (g->tx_event_flags_group_id == TX_EVENT_FLAGS_ID));
}

References __stk_forceinline, IsValidEf(), TX_EVENT_FLAGS_GROUP_STRUCT::tx_event_flags_group_id, and TX_EVENT_FLAGS_ID.

Referenced by IsValidEf().

Here is the call graph for this function:

Here is the caller graph for this function:

IsValidMutex()

__stk_forceinline bool anonymous_namespace{threadx_stk.cpp}::IsValidMutex

(

const TX_MUTEX *

m

)

Definition at line 1110 of file threadx_stk.cpp.

{ return ((m != nullptr) && (m->tx_mutex_id == TX_MUTEX_ID)); }

References __stk_forceinline, IsValidMutex(), TX_MUTEX_ID, and TX_MUTEX_STRUCT::tx_mutex_id.

Referenced by IsValidMutex().

Here is the call graph for this function:

Here is the caller graph for this function:

IsValidQueue()

__stk_forceinline bool anonymous_namespace{threadx_stk.cpp}::IsValidQueue

(

const TX_QUEUE *

q

)

Definition at line 1705 of file threadx_stk.cpp.

{ return ((q != nullptr) && (q->tx_queue_id == TX_QUEUE_ID)); }

References __stk_forceinline, IsValidQueue(), TX_QUEUE_ID, and TX_QUEUE_STRUCT::tx_queue_id.

Referenced by IsValidQueue(), and QueueSend().

Here is the call graph for this function:

Here is the caller graph for this function:

IsValidSem()

__stk_forceinline bool anonymous_namespace{threadx_stk.cpp}::IsValidSem

(

const TX_SEMAPHORE *

s

)

Definition at line 1266 of file threadx_stk.cpp.

{ return ((s != nullptr) && (s->tx_semaphore_id == TX_SEMAPHORE_ID)); }

References __stk_forceinline, IsValidSem(), TX_SEMAPHORE_ID, and TX_SEMAPHORE_STRUCT::tx_semaphore_id.

Referenced by IsValidSem().

Here is the call graph for this function:

Here is the caller graph for this function:

IsValidThread()

__stk_forceinline bool anonymous_namespace{threadx_stk.cpp}::IsValidThread

(

const TX_THREAD *

tx

)

Definition at line 218 of file threadx_stk.cpp.

{
    return ((tx != nullptr) && (tx->tx_thread_id == TX_THREAD_ID));
}

References __stk_forceinline, IsValidThread(), TX_THREAD_ID, and TX_THREAD_STRUCT::tx_thread_id.

Referenced by IsValidThread().

Here is the call graph for this function:

Here is the caller graph for this function:

IsValidTimer()

__stk_forceinline bool anonymous_namespace{threadx_stk.cpp}::IsValidTimer

(

const TX_TIMER *

t

)

Definition at line 2614 of file threadx_stk.cpp.

{ return ((t != nullptr) && (t->tx_timer_id == TX_TIMER_ID)); }

References __stk_forceinline, IsValidTimer(), TX_TIMER_ID, and TX_TIMER_STRUCT::tx_timer_id.

Referenced by IsValidTimer().

Here is the call graph for this function:

Here is the caller graph for this function:

KernelInitialized()

__stk_forceinline bool anonymous_namespace{threadx_stk.cpp}::KernelInitialized

(

)

Definition at line 73 of file threadx_stk.cpp.

{
    return (g_StkKernel.GetState() != stk::IKernel::KSTATE_INACTIVE);
}

References __stk_forceinline, g_StkKernel, KernelInitialized(), and stk::IKernel::KSTATE_INACTIVE.

Referenced by KernelInitialized().

Here is the call graph for this function:

Here is the caller graph for this function:

KernelRunning()

__stk_forceinline bool anonymous_namespace{threadx_stk.cpp}::KernelRunning

(

)

Definition at line 68 of file threadx_stk.cpp.

{
    return (g_StkKernel.GetState() == stk::IKernel::KSTATE_RUNNING);
}

References __stk_forceinline, g_StkKernel, KernelRunning(), and stk::IKernel::KSTATE_RUNNING.

Referenced by CurrentThread(), KernelRunning(), and WaitThreadRemoved().

Here is the call graph for this function:

Here is the caller graph for this function:

MutexOf()

__stk_forceinline stk::sync::Mutex * anonymous_namespace{threadx_stk.cpp}::MutexOf

(

TX_MUTEX *

m

)

Definition at line 1106 of file threadx_stk.cpp.

{
    return static_cast<stk::sync::Mutex *>(static_cast<void *>(m->tx_mutex_stk_storage));
}

References __stk_forceinline, MutexOf(), and TX_MUTEX_STRUCT::tx_mutex_stk_storage.

Referenced by MutexOf().

Here is the call graph for this function:

Here is the caller graph for this function:

QueueOf()

__stk_forceinline stk::sync::MessageQueue * anonymous_namespace{threadx_stk.cpp}::QueueOf

(

TX_QUEUE *

q

)

Definition at line 1701 of file threadx_stk.cpp.

{
    return static_cast<stk::sync::MessageQueue *>(static_cast<void *>(q->tx_queue_stk_storage));
}

References __stk_forceinline, QueueOf(), and TX_QUEUE_STRUCT::tx_queue_stk_storage.

Referenced by QueueOf(), and QueueSend().

Here is the call graph for this function:

Here is the caller graph for this function:

QueueSend()

UINT anonymous_namespace{threadx_stk.cpp}::QueueSend	(	TX_QUEUE *	queue_ptr,
		void *	source_ptr,
		ULONG	wait_option,
		bool	front )

Definition at line 1832 of file threadx_stk.cpp.

{
    UINT result;
 
    if (!IsValidQueue(queue_ptr))
    {
        result = TX_QUEUE_ERROR;
    }
    else if (source_ptr == nullptr)
    {
        result = TX_PTR_ERROR;
    }
    else if (!CanBlock(wait_option))
    {
        result = TX_WAIT_ERROR;
    }
    else
    {
        stk::sync::MessageQueue *const q = QueueOf(queue_ptr);
        const stk::Timeout timeout       = ToStkTimeout(wait_option);
 
        {
            const ScopedWaitKind ws(TX_QUEUE_SUSP, wait_option);
 
            result = WaitResultToTx((front ? q->PutFrontEx(source_ptr, timeout) : q->PutEx(source_ptr, timeout)),
                                    TX_QUEUE_FULL);
        }
 
        if ((result == TX_SUCCESS) && (queue_ptr->tx_queue_send_notify != nullptr))
        {
            queue_ptr->tx_queue_send_notify(queue_ptr);
        }
    }
 
    return result;
}

References CanBlock(), IsValidQueue(), stk::sync::MessageQueue::PutEx(), stk::sync::MessageQueue::PutFrontEx(), QueueOf(), QueueSend(), ToStkTimeout(), TX_PTR_ERROR, TX_QUEUE_ERROR, TX_QUEUE_FULL, TX_QUEUE_STRUCT::tx_queue_send_notify, TX_QUEUE_SUSP, TX_SUCCESS, TX_WAIT_ERROR, VOID, and WaitResultToTx().

Referenced by QueueSend().

Here is the call graph for this function:

Here is the caller graph for this function:

RegisterThread()

UINT anonymous_namespace{threadx_stk.cpp}::RegisterThread

(

StkThread *

th

)

Definition at line 383 of file threadx_stk.cpp.

{
    UINT result = TX_SUCCESS;
 
    if (g_StkKernel.GetSwitchStrategy()->GetSize() >= static_cast<size_t>(TX_STK_MAX_THREADS + 1U))
    {
        result = TX_START_ERROR; // out of kernel task slots: increase TX_STK_MAX_THREADS
    }
    else
    {
        th->m_removed    = false;
        th->m_registered = true;
        th->m_tx->tx_thread_state = TX_READY;
 
        g_StkKernel.AddTask(th);
    }
 
    return result;
}

References g_StkKernel, anonymous_namespace{threadx_stk.cpp}::StkThread::m_registered, anonymous_namespace{threadx_stk.cpp}::StkThread::m_removed, anonymous_namespace{threadx_stk.cpp}::StkThread::m_tx, RegisterThread(), TX_READY, TX_START_ERROR, TX_STK_MAX_THREADS, TX_SUCCESS, and TX_THREAD_STRUCT::tx_thread_state.

Referenced by RegisterThread().

Here is the call graph for this function:

Here is the caller graph for this function:

SemOf()

__stk_forceinline stk::sync::Semaphore * anonymous_namespace{threadx_stk.cpp}::SemOf

(

TX_SEMAPHORE *

s

)

Definition at line 1262 of file threadx_stk.cpp.

{
    return static_cast<stk::sync::Semaphore *>(static_cast<void *>(s->tx_semaphore_stk_storage));
}

References __stk_forceinline, SemOf(), and TX_SEMAPHORE_STRUCT::tx_semaphore_stk_storage.

Referenced by SemOf().

Here is the call graph for this function:

Here is the caller graph for this function:

ThreadFromTid()

TX_THREAD * anonymous_namespace{threadx_stk.cpp}::ThreadFromTid

(

stk::TId

tid

)

Definition at line 241 of file threadx_stk.cpp.

{
    TX_THREAD *tx = nullptr;
 
    if ((tid != stk::TID_NONE) && (tid != g_TimerTid) && !stk::IsIsrTid(tid))
    {
        tx = static_cast<StkThread *>(stk::GetUserTaskFromTid(tid))->m_tx;
    }
 
    return tx;
}

References g_TimerTid, stk::GetUserTaskFromTid(), stk::IsIsrTid(), ThreadFromTid(), and stk::TID_NONE.

Referenced by FillSuspended(), FillSuspended(), and ThreadFromTid().

Here is the call graph for this function:

Here is the caller graph for this function:

ThreadOf()

__stk_forceinline StkThread * anonymous_namespace{threadx_stk.cpp}::ThreadOf

(

TX_THREAD *

tx

)

Definition at line 213 of file threadx_stk.cpp.

{
    return static_cast<StkThread *>(static_cast<void *>(tx->tx_thread_stk_storage));
}

References __stk_forceinline, ThreadOf(), and TX_THREAD_STRUCT::tx_thread_stk_storage.

Referenced by ThreadOf(), and ThreadStateOf().

Here is the call graph for this function:

Here is the caller graph for this function:

ThreadStateOf()

UINT anonymous_namespace{threadx_stk.cpp}::ThreadStateOf

(

TX_THREAD *

tx

)

Definition at line 335 of file threadx_stk.cpp.

{
    UINT state = tx->tx_thread_state;
 
    if (state == TX_READY)
    {
        StkThread *const th = ThreadOf(tx);
 
        if (th->m_registered && !th->m_removed)
        {
            stk::TaskStateInfo info = { stk::TASK_STATE_REMOVED, nullptr, stk::WAIT_INFINITE };
 
            // fails only for a null task or without KERNEL_TELEMETRY: keep the lifecycle state then
            if (!g_StkKernel.GetTaskState(th, info))
            {
                info.state = stk::TASK_STATE_READY;
            }
 
            switch (info.state)
            {
            case stk::TASK_STATE_SLEEPING:
                state = TX_SLEEP;
                break;
 
            case stk::TASK_STATE_WAITING:
                state = ((th->m_wait_kind != TX_READY) ? th->m_wait_kind : static_cast<UINT>(TX_SLEEP));
                break;
 
            case stk::TASK_STATE_SUSPENDED:
                state = TX_SUSPENDED;
                break;
 
            case stk::TASK_STATE_EXITING:
                state = TX_COMPLETED;
                break;
 
            case stk::TASK_STATE_READY:
            case stk::TASK_STATE_REMOVED:
            default:
                break; // TX_READY
            }
        }
    }
 
    return state;
}

References g_StkKernel, anonymous_namespace{threadx_stk.cpp}::StkThread::m_registered, anonymous_namespace{threadx_stk.cpp}::StkThread::m_removed, anonymous_namespace{threadx_stk.cpp}::StkThread::m_wait_kind, stk::TaskStateInfo::state, stk::TASK_STATE_EXITING, stk::TASK_STATE_READY, stk::TASK_STATE_REMOVED, stk::TASK_STATE_SLEEPING, stk::TASK_STATE_SUSPENDED, stk::TASK_STATE_WAITING, ThreadOf(), ThreadStateOf(), TX_COMPLETED, TX_READY, TX_SLEEP, TX_SUSPENDED, TX_THREAD_STRUCT::tx_thread_state, and stk::WAIT_INFINITE.

Referenced by ThreadStateOf().

Here is the call graph for this function:

Here is the caller graph for this function:

TimerListInsert()

bool anonymous_namespace{threadx_stk.cpp}::TimerListInsert

(

TX_TIMER *

t

)

Definition at line 2491 of file threadx_stk.cpp.

{
    TX_TIMER *prev = nullptr;
    TX_TIMER *next = g_TimerHead;
 
    // stable: a timer is placed behind the timers expiring at the same tick
    while ((next != nullptr) && (next->tx_timer_stk_expiry <= t->tx_timer_stk_expiry))
    {
        prev = next;
        next = next->tx_timer_stk_next;
    }
 
    t->tx_timer_stk_prev = prev;
    t->tx_timer_stk_next = next;
 
    if (next != nullptr)
    {
        next->tx_timer_stk_prev = t;
    }
 
    if (prev != nullptr)
    {
        prev->tx_timer_stk_next = t;
    }
    else
    {
        g_TimerHead = t;
    }
 
    return (prev == nullptr);
}

References g_TimerHead, TimerListInsert(), TX_TIMER_STRUCT::tx_timer_stk_expiry, TX_TIMER_STRUCT::tx_timer_stk_next, and TX_TIMER_STRUCT::tx_timer_stk_prev.

Referenced by anonymous_namespace{threadx_stk.cpp}::StkTimerThread::Run(), and TimerListInsert().

Here is the call graph for this function:

Here is the caller graph for this function:

TimerListRemove()

void anonymous_namespace{threadx_stk.cpp}::TimerListRemove

(

TX_TIMER *

t

)

Definition at line 2470 of file threadx_stk.cpp.

{
    if (t->tx_timer_stk_prev != nullptr)
    {
        t->tx_timer_stk_prev->tx_timer_stk_next = t->tx_timer_stk_next;
    }
    else
    {
        g_TimerHead = t->tx_timer_stk_next;
    }
 
    if (t->tx_timer_stk_next != nullptr)
    {
        t->tx_timer_stk_next->tx_timer_stk_prev = t->tx_timer_stk_prev;
    }
 
    t->tx_timer_stk_next = nullptr;
    t->tx_timer_stk_prev = nullptr;
}

References g_TimerHead, TimerListRemove(), TX_TIMER_STRUCT::tx_timer_stk_next, and TX_TIMER_STRUCT::tx_timer_stk_prev.

Referenced by anonymous_namespace{threadx_stk.cpp}::StkTimerThread::Run(), and TimerListRemove().

Here is the call graph for this function:

Here is the caller graph for this function:

ToStkTimeout()

__stk_forceinline stk::Timeout anonymous_namespace{threadx_stk.cpp}::ToStkTimeout

(

ULONG

wait_option

)

Definition at line 79 of file threadx_stk.cpp.

{
    stk::Timeout result;
 
    if (wait_option == TX_NO_WAIT)
    {
        result = stk::NO_WAIT;
    }
    else if (wait_option >= static_cast<ULONG>(stk::WAIT_INFINITE))
    {
        result = stk::WAIT_INFINITE;
    }
    else
    {
        result = static_cast<stk::Timeout>(wait_option);
    }
 
    return result;
}

References __stk_forceinline, stk::NO_WAIT, ToStkTimeout(), TX_NO_WAIT, and stk::WAIT_INFINITE.

Referenced by QueueSend(), and ToStkTimeout().

Here is the call graph for this function:

Here is the caller graph for this function:

ToStkWeight()

__stk_forceinline stk::Weight anonymous_namespace{threadx_stk.cpp}::ToStkWeight	(	UINT	priority,
		UINT	threshold )

Definition at line 100 of file threadx_stk.cpp.

{
    return StkStrategy::FromThreadX(static_cast<uint8_t>(priority), static_cast<uint8_t>(threshold));
}

References __stk_forceinline, stk::SwitchStrategyPreemptionThreshold< 32, true >::FromThreadX(), and ToStkWeight().

Referenced by anonymous_namespace{threadx_stk.cpp}::StkTimerThread::GetWeight(), anonymous_namespace{threadx_stk.cpp}::StkThread::StkThread(), and ToStkWeight().

Here is the call graph for this function:

Here is the caller graph for this function:

WaitResultToTx()

__stk_forceinline UINT anonymous_namespace{threadx_stk.cpp}::WaitResultToTx	(	stk::EWaitResult	wr,
		UINT	timeout_status )

Definition at line 107 of file threadx_stk.cpp.

{
    UINT result;
 
    switch (wr)
    {
    case stk::WAIT_RESULT_SIGNAL:
        result = TX_SUCCESS;
        break;
 
    case stk::WAIT_RESULT_TIMEOUT:
        result = timeout_status;
        break;
 
    case stk::WAIT_RESULT_CANCELED:
        result = TX_WAIT_ABORTED;
        break;
 
    case stk::WAIT_RESULT_FAIL:
    default:
        result = TX_WAIT_ERROR;
        break;
    }
 
    return result;
}

References __stk_forceinline, TX_SUCCESS, TX_WAIT_ABORTED, TX_WAIT_ERROR, stk::WAIT_RESULT_CANCELED, stk::WAIT_RESULT_FAIL, stk::WAIT_RESULT_SIGNAL, stk::WAIT_RESULT_TIMEOUT, and WaitResultToTx().

Referenced by QueueSend(), and WaitResultToTx().

Here is the call graph for this function:

Here is the caller graph for this function:

WaitThreadRemoved()

bool anonymous_namespace{threadx_stk.cpp}::WaitThreadRemoved

(

const StkThread *

th

)

Definition at line 404 of file threadx_stk.cpp.

{
    // removal is processed by the kernel tick, a few ticks at most
    for (uint32_t attempts = 0U; (!th->m_removed && (attempts < 1000U)); ++attempts)
    {
        if (!KernelRunning() || InIsr())
        {
            break;
        }
 
        stk::Sleep(1);
    }
 
    return th->m_removed;
}

References InIsr(), KernelRunning(), anonymous_namespace{threadx_stk.cpp}::StkThread::m_removed, stk::Sleep(), and WaitThreadRemoved().

Referenced by WaitThreadRemoved().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

BLOCK_HDR_SIZE

const size_t anonymous_namespace{threadx_stk.cpp}::BLOCK_HDR_SIZE = sizeof(void *)

Definition at line 1936 of file threadx_stk.cpp.

g_BytePools

StkBytePool* anonymous_namespace{threadx_stk.cpp}::g_BytePools = nullptr

Definition at line 2180 of file threadx_stk.cpp.

Referenced by BytePoolFind(), BytePoolLink(), and BytePoolUnlink().

g_IntDisabled

volatile bool anonymous_namespace{threadx_stk.cpp}::g_IntDisabled = false

Definition at line 438 of file threadx_stk.cpp.

g_TimeOffset

int64_t anonymous_namespace{threadx_stk.cpp}::g_TimeOffset = 0

Definition at line 465 of file threadx_stk.cpp.

g_TimerEvent

stk::sync::Event anonymous_namespace{threadx_stk.cpp}::g_TimerEvent(false, false)	(	false	,
		false	)

Referenced by anonymous_namespace{threadx_stk.cpp}::StkTimerThread::Run().

g_TimerHead

TX_TIMER* anonymous_namespace{threadx_stk.cpp}::g_TimerHead = nullptr

Definition at line 2466 of file threadx_stk.cpp.

Referenced by anonymous_namespace{threadx_stk.cpp}::StkTimerThread::Run(), TimerListInsert(), and TimerListRemove().

g_TimerThread

StkTimerThread anonymous_namespace{threadx_stk.cpp}::g_TimerThread

Definition at line 2464 of file threadx_stk.cpp.

Referenced by EnsureTimerThread().

g_TimerTid

stk::TId anonymous_namespace{threadx_stk.cpp}::g_TimerTid = stk::TID_NONE

Definition at line 61 of file threadx_stk.cpp.

Referenced by CurrentThread(), EnsureTimerThread(), and ThreadFromTid().