stk::pthread Namespace Reference

Classes
class	PthreadTask
struct	KeyEntry

Typedefs
using	ThreadCtrl = pthread_stk_ctrl_t

Functions
static IKernel *	ToKernel (stk_kernel_t *k)
template<typename T>
static T	LoadAcquire (T *p)
template<typename T>
static void	StoreRelease (T *p, T v)
template<typename T, typename Mem>
static T *	EnsureObject (void **slot, Mem &mem)
static sync::Mutex *	HandleOf (pthread_mutex_t *o)
static sync::Mutex *	HandleOf (pthread_once_t *o)
static sync::ConditionVariable *	HandleOf (pthread_cond_t *o)
static sync::RWMutex *	HandleOf (pthread_rwlock_t *o)
static hw::SpinLock *	HandleOf (pthread_spinlock_t *o)
static sync::Barrier *	HandleOf (pthread_barrier_t *o)
static void	RunKeyDestructors (ThreadCtrl *ctrl)
	STK_BLOCKPOOL_STORAGE_DECL (s_PthreadStackStorage, STK_C_PTHREAD_MAX_THREADS, kDefaultStackBytes)
static stk_blockpool_t *	EnsureStackPool ()
static void	ReleaseThreadResources (ThreadCtrl *ctrl)
static void	WaitForTaskExit (ThreadCtrl *ctrl)
static void	ReaperEntry (void *arg)
static void	EnsureReaper ()
static void	EnqueueReap (ThreadCtrl *ctrl)
static ThreadCtrl *	DequeueReap ()
static void	MaybeReap (ThreadCtrl *ctrl)
static ThreadCtrl *	AcquireThreadSlot ()
static bool	AllocateStack (ThreadCtrl *ctrl, const pthread_attr_t *attr, std::size_t stack_bytes)
static Timeout	TimespecToRelativeTimeout (const struct timespec *abstime)
static sync::Mutex *	EnsureMutex (pthread_mutex_t *m)
static bool	IsMutexOwner (const sync::Mutex *m)
static bool	IsValidMutexType (int type)
static int	PreLockCheck (const pthread_mutex_t *pm, const sync::Mutex *m, int errorcheck_code)
static sync::ConditionVariable *	EnsureCond (pthread_cond_t *c)
static sync::RWMutex *	EnsureRWLock (pthread_rwlock_t *rw)
static sync::Mutex *	EnsureOnceMutex (pthread_once_t *o)
static ThreadCtrl *	CurrentCtrl ()
static ThreadCtrl *	CurrentCtrlOrAdopt ()
static bool	IsKeyUsed (pthread_key_t key)

Variables
constexpr std::size_t	kDefaultStackBytes
constexpr int	kOnceRunning = 1
constexpr int	kOnceDone = 2
static ThreadCtrl	s_Threads [STK_C_PTHREAD_MAX_THREADS]
static stk_kernel_t *	s_BoundKernel = nullptr
static stk_blockpool_t *	s_StackPool = nullptr
static ThreadCtrl *	s_ReapQueue [STK_C_PTHREAD_MAX_THREADS]
static std::size_t	s_ReapHead = 0U
static std::size_t	s_ReapCount = 0U
static sync::Semaphore *	s_ReapSem = nullptr
struct {
uint8_t   stk::pthread::data [sizeof(sync::Semaphore)]
}	s_ReapSemBuf
static stk_task_t *	s_ReaperTask = nullptr
static stk_word_t	s_ReaperStack [STK_C_PTHREAD_REAPER_STACK_WORDS]
static KeyEntry	s_Keys [STK_C_PTHREAD_KEYS_MAX]

Typedef Documentation

ThreadCtrl

using stk::pthread::ThreadCtrl = pthread_stk_ctrl_t

Definition at line 173 of file stk_c_pthread.cpp.

Function Documentation

AcquireThreadSlot()

ThreadCtrl * stk::pthread::AcquireThreadSlot ( )

static

Definition at line 406 of file stk_c_pthread.cpp.

{
    ThreadCtrl *result = nullptr;
 
    {
        const CsLock cs_;
 
        for (std::size_t i = 0U; (result == nullptr) && (i < STK_C_PTHREAD_MAX_THREADS); ++i)
        {
            if (!s_Threads[i].busy)
            {
                s_Threads[i].Reset();
                s_Threads[i].busy = true;
                result = &s_Threads[i];
            }
        }
    }
 
    return result;
}

References s_Threads, and STK_C_PTHREAD_MAX_THREADS.

Referenced by CurrentCtrlOrAdopt(), and pthread_create().

Here is the caller graph for this function:

AllocateStack()

bool stk::pthread::AllocateStack ( ThreadCtrl * ctrl, const pthread_attr_t * attr, std::size_t stack_bytes )

static

Definition at line 483 of file stk_c_pthread.cpp.

{
    if ((attr != nullptr) && (attr->__ext_stack != nullptr))
    {
        ctrl->stack           = attr->__ext_stack;
        ctrl->stack_owned     = false;
        ctrl->stack_from_pool = false;
    }
    else
    {
        void *blk = nullptr;
 
        if (stack_bytes == kDefaultStackBytes)
        {
            stk_blockpool_t *const pool = EnsureStackPool();
            if (pool != nullptr)
            {
                blk = stk_blockpool_try_alloc(pool);
            }
        }
 
        if (blk != nullptr)
        {
            ctrl->stack           = static_cast<stk_word_t *>(blk);
            ctrl->stack_owned     = true;
            ctrl->stack_from_pool = true;
        }
        else
        {
            ctrl->stack           = static_cast<stk_word_t *>(malloc(stack_bytes));
            ctrl->stack_owned     = true;
            ctrl->stack_from_pool = false;
        }
    }
 
    return (ctrl->stack != nullptr);
}

References pthread_attr_t::__ext_stack, EnsureStackPool(), kDefaultStackBytes, malloc(), pthread_stk_ctrl_t::stack, pthread_stk_ctrl_t::stack_from_pool, pthread_stk_ctrl_t::stack_owned, and stk_blockpool_try_alloc().

Referenced by pthread_create().

Here is the call graph for this function:

Here is the caller graph for this function:

CurrentCtrl()

ThreadCtrl * stk::pthread::CurrentCtrl ( )

static

Definition at line 645 of file stk_c_pthread.cpp.

{
    return hw::GetTlsPtr<ThreadCtrl>();
}

Referenced by CurrentCtrlOrAdopt(), pthread_exit(), pthread_getspecific(), and pthread_join().

Here is the caller graph for this function:

CurrentCtrlOrAdopt()

ThreadCtrl * stk::pthread::CurrentCtrlOrAdopt ( )

static

Definition at line 657 of file stk_c_pthread.cpp.

{
    ThreadCtrl *ctrl = CurrentCtrl();
    if (ctrl == nullptr)
    {
        ctrl = AcquireThreadSlot();
        if (ctrl != nullptr)
        {
            ctrl->adopted  = true;
            ctrl->detached = true; // not joinable, never handed to the reaper
            hw::SetTlsPtr(static_cast<void *>(ctrl));
        }
    }
 
    return ctrl;
}

References AcquireThreadSlot(), pthread_stk_ctrl_t::adopted, CurrentCtrl(), and pthread_stk_ctrl_t::detached.

Referenced by pthread_self(), and pthread_setspecific().

Here is the call graph for this function:

Here is the caller graph for this function:

DequeueReap()

ThreadCtrl * stk::pthread::DequeueReap ( )

static

Definition at line 345 of file stk_c_pthread.cpp.

{
    ThreadCtrl *result = nullptr;
 
    {
        const CsLock cs_;
 
        if (s_ReapCount > 0U)
        {
            result = s_ReapQueue[s_ReapHead];
            s_ReapHead = (s_ReapHead + 1U) % STK_C_PTHREAD_MAX_THREADS;
            --s_ReapCount;
        }
    }
 
    return result;
}

References s_ReapCount, s_ReapHead, s_ReapQueue, and STK_C_PTHREAD_MAX_THREADS.

Referenced by ReaperEntry().

Here is the caller graph for this function:

EnqueueReap()

void stk::pthread::EnqueueReap ( ThreadCtrl * ctrl )

static

Definition at line 330 of file stk_c_pthread.cpp.

{
    STK_C_ASSERT(s_ReaperTask != nullptr);
 
    const CsLock cs_;
 
    STK_C_ASSERT(s_ReapCount < STK_C_PTHREAD_MAX_THREADS);
    if (s_ReapCount < STK_C_PTHREAD_MAX_THREADS)
    {
        const std::size_t tail = (s_ReapHead + s_ReapCount) % STK_C_PTHREAD_MAX_THREADS;
        s_ReapQueue[tail] = ctrl;
        ++s_ReapCount;
    }
}

References s_ReapCount, s_ReaperTask, s_ReapHead, s_ReapQueue, STK_C_ASSERT, and STK_C_PTHREAD_MAX_THREADS.

Referenced by MaybeReap().

Here is the caller graph for this function:

EnsureCond()

sync::ConditionVariable * stk::pthread::EnsureCond ( pthread_cond_t * c )

static

Definition at line 624 of file stk_c_pthread.cpp.

{
    return EnsureObject<sync::ConditionVariable>(&c->__handle, c->__mem);
}

References pthread_cond_t::__handle, pthread_cond_t::__mem, and EnsureObject().

Referenced by pthread_cond_broadcast(), pthread_cond_signal(), pthread_cond_timedwait(), and pthread_cond_wait().

Here is the call graph for this function:

Here is the caller graph for this function:

EnsureMutex()

sync::Mutex * stk::pthread::EnsureMutex ( pthread_mutex_t * m )

static

Definition at line 583 of file stk_c_pthread.cpp.

{
    return EnsureObject<sync::Mutex>(&m->__handle, m->__mem);
}

References pthread_mutex_t::__handle, pthread_mutex_t::__mem, and EnsureObject().

Referenced by pthread_mutex_lock(), pthread_mutex_timedlock(), and pthread_mutex_trylock().

Here is the call graph for this function:

Here is the caller graph for this function:

EnsureObject()

template<typename T, typename Mem>

T * stk::pthread::EnsureObject ( void ** slot, Mem & mem )

static

Definition at line 226 of file stk_c_pthread.cpp.

{
    void *h = LoadAcquire(slot);
    if (h == nullptr)
    {
        const CsLock cs_;
 
        h = *slot; // re-check under the lock
        if (h == nullptr)
        {
            h = ConstructIn<T>(mem);
            StoreRelease(slot, h);
        }
    }
 
    return static_cast<T *>(h);
}

References stk::ConstructIn(), LoadAcquire(), and StoreRelease().

Referenced by EnsureCond(), EnsureMutex(), EnsureOnceMutex(), and EnsureRWLock().

Here is the call graph for this function:

Here is the caller graph for this function:

EnsureOnceMutex()

sync::Mutex * stk::pthread::EnsureOnceMutex ( pthread_once_t * o )

static

Definition at line 634 of file stk_c_pthread.cpp.

{
    return EnsureObject<sync::Mutex>(&o->__handle, o->__mem);
}

References pthread_once_t::__handle, pthread_once_t::__mem, and EnsureObject().

Referenced by pthread_once().

Here is the call graph for this function:

Here is the caller graph for this function:

EnsureReaper()

void stk::pthread::EnsureReaper ( )

static

Definition at line 309 of file stk_c_pthread.cpp.

{
    if (s_ReaperTask == nullptr)
    {
        STK_C_ASSERT(s_BoundKernel != nullptr);
 
        if (s_ReapSem == nullptr)
        {
            s_ReapSem = ConstructIn<sync::Semaphore>(s_ReapSemBuf, 0U);
        }
 
        s_ReaperTask = stk_task_create_user(ReaperEntry, nullptr, s_ReaperStack,
                                            STK_C_PTHREAD_REAPER_STACK_WORDS);
        if (s_ReaperTask != nullptr)
        {
            stk_task_set_name(s_ReaperTask, "pthread_reaper");
            stk_kernel_add_task(s_BoundKernel, s_ReaperTask);
        }
    }
}

References stk::ConstructIn(), ReaperEntry(), s_BoundKernel, s_ReaperStack, s_ReaperTask, s_ReapSem, s_ReapSemBuf, STK_C_ASSERT, STK_C_PTHREAD_REAPER_STACK_WORDS, stk_kernel_add_task(), stk_task_create_user(), and stk_task_set_name().

Referenced by stk_pthread_bind_kernel().

Here is the call graph for this function:

Here is the caller graph for this function:

EnsureRWLock()

sync::RWMutex * stk::pthread::EnsureRWLock ( pthread_rwlock_t * rw )

static

Definition at line 629 of file stk_c_pthread.cpp.

{
    return EnsureObject<sync::RWMutex>(&rw->__handle, rw->__mem);
}

References pthread_rwlock_t::__handle, pthread_rwlock_t::__mem, and EnsureObject().

Referenced by pthread_rwlock_rdlock(), pthread_rwlock_timedrdlock(), pthread_rwlock_timedwrlock(), pthread_rwlock_tryrdlock(), pthread_rwlock_trywrlock(), and pthread_rwlock_wrlock().

Here is the call graph for this function:

Here is the caller graph for this function:

EnsureStackPool()

stk_blockpool_t * stk::pthread::EnsureStackPool ( )

static

Definition at line 268 of file stk_c_pthread.cpp.

{
    stk_blockpool_t *pool = LoadAcquire(&s_StackPool);
    if (pool == nullptr)
    {
        const CsLock cs_;
 
        pool = s_StackPool;
        if (pool == nullptr)
        {
            pool = stk_blockpool_create_static(
                STK_C_PTHREAD_MAX_THREADS,
                kDefaultStackBytes,
                reinterpret_cast<uint8_t *>(s_PthreadStackStorage),
                sizeof(s_PthreadStackStorage),
                "pthread_stacks");
            StoreRelease(&s_StackPool, pool);
        }
    }
 
    return pool;
}

References kDefaultStackBytes, LoadAcquire(), s_StackPool, stk_blockpool_create_static(), STK_C_PTHREAD_MAX_THREADS, and StoreRelease().

Referenced by AllocateStack().

Here is the call graph for this function:

Here is the caller graph for this function:

HandleOf() [1/6]

sync::Barrier * stk::pthread::HandleOf ( pthread_barrier_t * o )

inlinestatic

Definition at line 250 of file stk_c_pthread.cpp.

{ return static_cast<sync::Barrier *>(o->__handle); }

References pthread_barrier_t::__handle.

HandleOf() [2/6]

sync::ConditionVariable * stk::pthread::HandleOf ( pthread_cond_t * o )

inlinestatic

Definition at line 247 of file stk_c_pthread.cpp.

{ return static_cast<sync::ConditionVariable *>(o->__handle); }

References pthread_cond_t::__handle.

HandleOf() [3/6]

sync::Mutex * stk::pthread::HandleOf ( pthread_mutex_t * o )

inlinestatic

Definition at line 245 of file stk_c_pthread.cpp.

{ return static_cast<sync::Mutex *>(o->__handle); }

References pthread_mutex_t::__handle.

Referenced by pthread_barrier_destroy(), pthread_barrier_wait(), pthread_cond_destroy(), pthread_cond_timedwait(), pthread_cond_wait(), pthread_mutex_destroy(), pthread_mutex_unlock(), pthread_rwlock_destroy(), pthread_rwlock_unlock(), pthread_spin_destroy(), pthread_spin_lock(), pthread_spin_trylock(), and pthread_spin_unlock().

Here is the caller graph for this function:

HandleOf() [4/6]

sync::Mutex * stk::pthread::HandleOf ( pthread_once_t * o )

inlinestatic

Definition at line 246 of file stk_c_pthread.cpp.

{ return static_cast<sync::Mutex *>(o->__handle); }

References pthread_once_t::__handle.

HandleOf() [5/6]

sync::RWMutex * stk::pthread::HandleOf ( pthread_rwlock_t * o )

inlinestatic

Definition at line 248 of file stk_c_pthread.cpp.

{ return static_cast<sync::RWMutex *>(o->__handle); }

References pthread_rwlock_t::__handle.

HandleOf() [6/6]

hw::SpinLock * stk::pthread::HandleOf ( pthread_spinlock_t * o )

inlinestatic

Definition at line 249 of file stk_c_pthread.cpp.

{ return static_cast<hw::SpinLock *>(o->__handle); }

References pthread_spinlock_t::__handle.

IsKeyUsed()

bool stk::pthread::IsKeyUsed ( pthread_key_t key )

inlinestatic

Definition at line 687 of file stk_c_pthread.cpp.

{
    return (key < STK_C_PTHREAD_KEYS_MAX) && s_Keys[key].used;
}

References s_Keys, and STK_C_PTHREAD_KEYS_MAX.

Referenced by pthread_getspecific(), and pthread_setspecific().

Here is the caller graph for this function:

IsMutexOwner()

bool stk::pthread::IsMutexOwner ( const sync::Mutex * m )

inlinestatic

Definition at line 588 of file stk_c_pthread.cpp.

{
    return (m->GetOwner() == IKernelService::GetInstance()->GetTid());
}

References stk::IKernelService::GetInstance(), and stk::sync::Mutex::GetOwner().

Referenced by PreLockCheck(), pthread_cond_timedwait(), pthread_cond_wait(), pthread_mutex_unlock(), and pthread_once().

Here is the call graph for this function:

Here is the caller graph for this function:

IsValidMutexType()

bool stk::pthread::IsValidMutexType ( int type )

inlinestatic

Definition at line 593 of file stk_c_pthread.cpp.

{
    return (type == PTHREAD_MUTEX_NORMAL) ||
           (type == PTHREAD_MUTEX_ERRORCHECK) ||
           (type == PTHREAD_MUTEX_RECURSIVE);
}

References PTHREAD_MUTEX_ERRORCHECK, PTHREAD_MUTEX_NORMAL, and PTHREAD_MUTEX_RECURSIVE.

Referenced by pthread_mutex_init(), and pthread_mutexattr_settype().

Here is the caller graph for this function:

LoadAcquire()

template<typename T>

T stk::pthread::LoadAcquire ( T * p )

inlinestatic

Definition at line 219 of file stk_c_pthread.cpp.

{ return *static_cast<volatile T *>(p); }

Referenced by EnsureObject(), EnsureStackPool(), and pthread_once().

Here is the caller graph for this function:

MaybeReap()

void stk::pthread::MaybeReap ( ThreadCtrl * ctrl )

static

Definition at line 382 of file stk_c_pthread.cpp.

{
    bool do_reap = false;
 
    {
        const CsLock cs_;
 
        if (ctrl->finished && ctrl->detached && !ctrl->reclaimed)
        {
            ctrl->reclaimed = true;
            do_reap = true;
        }
    }
 
    if (do_reap)
    {
        EnqueueReap(ctrl);
        s_ReapSem->Signal();
    }
}

References pthread_stk_ctrl_t::detached, EnqueueReap(), pthread_stk_ctrl_t::finished, pthread_stk_ctrl_t::reclaimed, and s_ReapSem.

Referenced by pthread_detach(), pthread_exit(), and stk::pthread::PthreadTask::Run().

Here is the call graph for this function:

Here is the caller graph for this function:

PreLockCheck()

int stk::pthread::PreLockCheck ( const pthread_mutex_t * pm, const sync::Mutex * m, int errorcheck_code )

static

Definition at line 605 of file stk_c_pthread.cpp.

{
    int result = 0;
 
    if (IsMutexOwner(m))
    {
        if (pm->__type == PTHREAD_MUTEX_ERRORCHECK)
        {
            result = errorcheck_code;
        }
        else
        {
            result = (m->GetRecursionCount() >= sync::Mutex::RECURSION_MAX) ? EAGAIN : 0;
        }
    }
 
    return result;
}

References pthread_mutex_t::__type, stk::sync::Mutex::GetRecursionCount(), IsMutexOwner(), PTHREAD_MUTEX_ERRORCHECK, and stk::sync::Mutex::RECURSION_MAX.

Referenced by pthread_mutex_lock(), pthread_mutex_timedlock(), and pthread_mutex_trylock().

Here is the call graph for this function:

Here is the caller graph for this function:

ReaperEntry()

void stk::pthread::ReaperEntry ( void * arg )

static

Definition at line 363 of file stk_c_pthread.cpp.

{
    for (;;)
    {
        STK_C_ASSERT(s_ReapSem != nullptr);
        (void)s_ReapSem->Wait(); // WAIT_INFINITE
 
        ThreadCtrl *const ctrl = DequeueReap();
        if (ctrl != nullptr)
        {
            WaitForTaskExit(ctrl);
            ReleaseThreadResources(ctrl);
        }
    }
}

References DequeueReap(), ReleaseThreadResources(), s_ReapSem, STK_C_ASSERT, and WaitForTaskExit().

Referenced by EnsureReaper().

Here is the call graph for this function:

Here is the caller graph for this function:

ReleaseThreadResources()

void stk::pthread::ReleaseThreadResources ( ThreadCtrl * ctrl )

static

Definition at line 453 of file stk_c_pthread.cpp.

{
    if (ctrl->done_event != nullptr)
    {
        ctrl->done_event->~Event();
        ctrl->done_event = nullptr;
    }
 
    if (ctrl->stack_owned && (ctrl->stack != nullptr))
    {
        if (ctrl->stack_from_pool)
        {
            (void)stk_blockpool_free(s_StackPool, ctrl->stack);
        }
        else
        {
            free(ctrl->stack);
        }
    }
    ctrl->stack = nullptr;
 
    {
        const CsLock cs_;
 
        ctrl->busy = false;
    }
}

References pthread_stk_ctrl_t::busy, pthread_stk_ctrl_t::done_event, free(), s_StackPool, pthread_stk_ctrl_t::stack, pthread_stk_ctrl_t::stack_from_pool, pthread_stk_ctrl_t::stack_owned, stk_blockpool_free(), and stk::sync::Event::~Event().

Referenced by pthread_join(), and ReaperEntry().

Here is the call graph for this function:

Here is the caller graph for this function:

RunKeyDestructors()

void stk::pthread::RunKeyDestructors ( ThreadCtrl * ctrl )

static

Definition at line 699 of file stk_c_pthread.cpp.

{
    bool more = true;
 
    for (int iter = 0; more && (iter < PTHREAD_DESTRUCTOR_ITERATIONS); ++iter)
    {
        bool any_ran = false;
 
        for (std::size_t i = 0U; i < STK_C_PTHREAD_KEYS_MAX; ++i)
        {
            void *const value = ctrl->tsd[i];
 
            if (value != nullptr)
            {
                void (*destructor)(void *) = nullptr;
                {
                    const CsLock cs_;
 
                    if (s_Keys[i].used)
                    {
                        destructor = s_Keys[i].destructor;
                    }
                }
 
                ctrl->tsd[i] = nullptr; // clear before calling, per POSIX
                if (destructor != nullptr)
                {
                    destructor(value);
                    any_ran = true;
                }
            }
        }
 
        more = any_ran;
    }
}

References PTHREAD_DESTRUCTOR_ITERATIONS, s_Keys, STK_C_PTHREAD_KEYS_MAX, and pthread_stk_ctrl_t::tsd.

Referenced by pthread_exit(), and stk::pthread::PthreadTask::Run().

Here is the caller graph for this function:

STK_BLOCKPOOL_STORAGE_DECL()

stk::pthread::STK_BLOCKPOOL_STORAGE_DECL	(	s_PthreadStackStorage	,
		STK_C_PTHREAD_MAX_THREADS	,
		kDefaultStackBytes	)

References kDefaultStackBytes, and STK_C_PTHREAD_MAX_THREADS.

StoreRelease()

template<typename T>

void stk::pthread::StoreRelease ( T * p, T v )

inlinestatic

Definition at line 220 of file stk_c_pthread.cpp.

{ *static_cast<volatile T *>(p) = v; }

Referenced by EnsureObject(), EnsureStackPool(), and pthread_once().

Here is the caller graph for this function:

TimespecToRelativeTimeout()

Timeout stk::pthread::TimespecToRelativeTimeout ( const struct timespec * abstime )

static

Definition at line 563 of file stk_c_pthread.cpp.

{
    const stk_time_t now_ms    = static_cast<stk_time_t>(GetTimeNowMs());
    const stk_time_t target_ms = (static_cast<stk_time_t>(abstime->tv_sec) * 1000LL) +
                                 (static_cast<stk_time_t>(abstime->tv_nsec) / 1000000LL);
 
    stk_time_t rel_ms = target_ms - now_ms;
    if (rel_ms < 0LL)
    {
        rel_ms = 0LL;
    }
    else
    if (rel_ms > static_cast<stk_time_t>(INT32_MAX))
    {
        rel_ms = static_cast<stk_time_t>(INT32_MAX);
    }
 
    return GetTicksFromMsClampedToTimeout(static_cast<Timeout>(rel_ms));
}

References stk::GetTicksFromMsClampedToTimeout(), and stk::GetTimeNowMs().

Referenced by pthread_cond_timedwait(), pthread_mutex_timedlock(), pthread_rwlock_timedrdlock(), and pthread_rwlock_timedwrlock().

Here is the call graph for this function:

Here is the caller graph for this function:

ToKernel()

IKernel * stk::pthread::ToKernel ( stk_kernel_t * k )

inlinestatic

Definition at line 189 of file stk_c_pthread.cpp.

{
    return reinterpret_cast<IKernel *>(reinterpret_cast<void *>(k));
}

Referenced by pthread_create(), and pthread_exit().

Here is the caller graph for this function:

WaitForTaskExit()

void stk::pthread::WaitForTaskExit ( ThreadCtrl * ctrl )

static

Definition at line 434 of file stk_c_pthread.cpp.

{
    bool exited = false;
 
    while (!exited)
    {
        {
            const CsLock cs_;
 
            exited = ctrl->exited;
        }
 
        if (!exited)
        {
            SleepMs(1);
        }
    }
}

References pthread_stk_ctrl_t::exited, and stk::SleepMs().

Referenced by pthread_join(), and ReaperEntry().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

data

uint8_t stk::pthread::data[sizeof(sync::Semaphore)]

Definition at line 300 of file stk_c_pthread.cpp.

kDefaultStackBytes

std::size_t stk::pthread::kDefaultStackBytes

constexpr

Initial value:

                                     =
static_cast<std::size_t>(STK_C_PTHREAD_DEFAULT_STACK_WORDS) * sizeof(stk_word_t)

Definition at line 175 of file stk_c_pthread.cpp.

Referenced by AllocateStack(), EnsureStackPool(), pthread_attr_getstacksize(), pthread_create(), and STK_BLOCKPOOL_STORAGE_DECL().

kOnceDone

int stk::pthread::kOnceDone = 2

constexpr

Definition at line 180 of file stk_c_pthread.cpp.

Referenced by pthread_once().

kOnceRunning

int stk::pthread::kOnceRunning = 1

constexpr

Definition at line 179 of file stk_c_pthread.cpp.

Referenced by pthread_once().

s_BoundKernel

stk_kernel_t* stk::pthread::s_BoundKernel = nullptr

static

Definition at line 260 of file stk_c_pthread.cpp.

Referenced by EnsureReaper(), pthread_create(), pthread_exit(), and stk_pthread_bind_kernel().

s_Keys

KeyEntry stk::pthread::s_Keys[STK_C_PTHREAD_KEYS_MAX]

static

Definition at line 683 of file stk_c_pthread.cpp.

Referenced by IsKeyUsed(), pthread_key_create(), pthread_key_delete(), and RunKeyDestructors().

s_ReapCount

std::size_t stk::pthread::s_ReapCount = 0U

static

Definition at line 296 of file stk_c_pthread.cpp.

Referenced by DequeueReap(), and EnqueueReap().

s_ReaperStack

stk_word_t stk::pthread::s_ReaperStack[STK_C_PTHREAD_REAPER_STACK_WORDS]

static

Definition at line 303 of file stk_c_pthread.cpp.

Referenced by EnsureReaper().

s_ReaperTask

stk_task_t* stk::pthread::s_ReaperTask = nullptr

static

Definition at line 302 of file stk_c_pthread.cpp.

Referenced by EnqueueReap(), and EnsureReaper().

s_ReapHead

std::size_t stk::pthread::s_ReapHead = 0U

static

Definition at line 295 of file stk_c_pthread.cpp.

Referenced by DequeueReap(), and EnqueueReap().

s_ReapQueue

ThreadCtrl* stk::pthread::s_ReapQueue[STK_C_PTHREAD_MAX_THREADS]

static

Definition at line 294 of file stk_c_pthread.cpp.

Referenced by DequeueReap(), and EnqueueReap().

s_ReapSem

sync::Semaphore* stk::pthread::s_ReapSem = nullptr

static

Definition at line 298 of file stk_c_pthread.cpp.

Referenced by EnsureReaper(), MaybeReap(), and ReaperEntry().

[struct]

struct { ... } stk::pthread::s_ReapSemBuf

Referenced by EnsureReaper().

s_StackPool

stk_blockpool_t* stk::pthread::s_StackPool = nullptr

static

Definition at line 266 of file stk_c_pthread.cpp.

Referenced by EnsureStackPool(), and ReleaseThreadResources().

s_Threads

ThreadCtrl stk::pthread::s_Threads[STK_C_PTHREAD_MAX_THREADS]

static

Definition at line 182 of file stk_c_pthread.cpp.

Referenced by AcquireThreadSlot().