anonymous_namespace{stk_c_pthread.cpp} Namespace Reference

Classes
struct	KeyEntry

Typedefs
using	ThreadCtrl = pthread_stk_ctrl_t

Functions
	STK_BLOCKPOOL_STORAGE_DECL (s_PthreadStackStorage,(8U), kDefaultStackBytes)
stk_blockpool_t *	EnsureStackPool ()
void	ReleaseThreadResources (ThreadCtrl *ctrl)
void	WaitForTaskGone (stk_task_t *task)
void	ReaperEntry (void *arg)
void	EnsureReaper ()
void	EnqueueReap (ThreadCtrl *ctrl)
ThreadCtrl *	DequeueReap ()
void	MaybeReap (ThreadCtrl *ctrl)
ThreadCtrl *	AcquireThreadSlot ()
void	PthreadTrampoline (void *arg)
stk_timeout_t	TimespecToRelativeTimeout (const struct timespec *abstime)
stk_mutex_t *	EnsureMutex (pthread_mutex_t *m)
stk_cv_t *	EnsureCond (pthread_cond_t *c)
stk_rwmutex_t *	EnsureRWLock (pthread_rwlock_t *rw)
stk_mutex_t *	EnsureOnceMutex (pthread_once_t *o)
void	RunKeyDestructors (ThreadCtrl *ctrl)

Variables
constexpr std::size_t	kDefaultStackBytes
ThreadCtrl	s_Threads [(8U)]
stk_kernel_t *	s_BoundKernel = nullptr
stk_blockpool_t *	s_StackPool = nullptr
ThreadCtrl *	s_ReapQueue [(8U)]
std::size_t	s_ReapHead = 0U
std::size_t	s_ReapCount = 0U
stk_sem_t *	s_ReapSem = nullptr
stk_sem_mem_t	s_ReapSemMem
stk_task_t *	s_ReaperTask = nullptr
stk_word_t	s_ReaperStack [(256U)]
KeyEntry	s_Keys [(8U)]

Typedef Documentation

ThreadCtrl

using anonymous_namespace{stk_c_pthread.cpp}::ThreadCtrl = pthread_stk_ctrl_t

Definition at line 58 of file stk_c_pthread.cpp.

Function Documentation

AcquireThreadSlot()

ThreadCtrl * anonymous_namespace{stk_c_pthread.cpp}::AcquireThreadSlot

(

)

Definition at line 209 of file stk_c_pthread.cpp.

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

References s_Threads, STK_C_PTHREAD_MAX_THREADS, stk_critical_section_enter(), and stk_critical_section_exit().

Referenced by pthread_create().

Here is the call graph for this function:

Here is the caller graph for this function:

DequeueReap()

ThreadCtrl * anonymous_namespace{stk_c_pthread.cpp}::DequeueReap

(

)

Definition at line 151 of file stk_c_pthread.cpp.

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

References s_ReapCount, s_ReapHead, s_ReapQueue, STK_C_PTHREAD_MAX_THREADS, stk_critical_section_enter(), and stk_critical_section_exit().

Referenced by ReaperEntry().

Here is the call graph for this function:

Here is the caller graph for this function:

EnqueueReap()

void anonymous_namespace{stk_c_pthread.cpp}::EnqueueReap

(

ThreadCtrl *

ctrl

)

Definition at line 138 of file stk_c_pthread.cpp.

{
    stk_critical_section_enter();
    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;
    }
    stk_critical_section_exit();
}

References s_ReapCount, s_ReapHead, s_ReapQueue, STK_C_ASSERT, STK_C_PTHREAD_MAX_THREADS, stk_critical_section_enter(), and stk_critical_section_exit().

Referenced by MaybeReap().

Here is the call graph for this function:

Here is the caller graph for this function:

EnsureCond()

stk_cv_t * anonymous_namespace{stk_c_pthread.cpp}::EnsureCond

(

pthread_cond_t *

c

)

Definition at line 352 of file stk_c_pthread.cpp.

{
    if (c->__handle == nullptr)
    {
        stk_critical_section_enter();
        if (c->__handle == nullptr)
        {
            c->__handle = stk_cv_create(&c->__mem, sizeof(c->__mem));
        }
        stk_critical_section_exit();
    }
 
    return c->__handle;
}

References pthread_cond_t::__handle, pthread_cond_t::__mem, stk_critical_section_enter(), stk_critical_section_exit(), and stk_cv_create().

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()

stk_mutex_t * anonymous_namespace{stk_c_pthread.cpp}::EnsureMutex

(

pthread_mutex_t *

m

)

Definition at line 337 of file stk_c_pthread.cpp.

{
    if (m->__handle == nullptr)
    {
        stk_critical_section_enter();
        if (m->__handle == nullptr)
        {
            m->__handle = stk_mutex_create(&m->__mem, sizeof(m->__mem));
        }
        stk_critical_section_exit();
    }
 
    return m->__handle;
}

References pthread_mutex_t::__handle, pthread_mutex_t::__mem, stk_critical_section_enter(), stk_critical_section_exit(), and stk_mutex_create().

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:

EnsureOnceMutex()

stk_mutex_t * anonymous_namespace{stk_c_pthread.cpp}::EnsureOnceMutex

(

pthread_once_t *

o

)

Definition at line 382 of file stk_c_pthread.cpp.

{
    if (o->__handle == nullptr)
    {
        stk_critical_section_enter();
        if (o->__handle == nullptr)
        {
            o->__handle = stk_mutex_create(&o->__mem, sizeof(o->__mem));
        }
        stk_critical_section_exit();
    }
 
    return o->__handle;
}

References pthread_once_t::__handle, pthread_once_t::__mem, stk_critical_section_enter(), stk_critical_section_exit(), and stk_mutex_create().

Referenced by pthread_once().

Here is the call graph for this function:

Here is the caller graph for this function:

EnsureReaper()

void anonymous_namespace{stk_c_pthread.cpp}::EnsureReaper

(

)

Definition at line 112 of file stk_c_pthread.cpp.

{
    if (s_ReaperTask == nullptr)
    {
        stk_critical_section_enter();
        if (s_ReaperTask == nullptr)
        {
            STK_C_ASSERT(s_BoundKernel != nullptr);
 
            if (s_ReapSem == nullptr)
            {
                s_ReapSem = stk_sem_create(&s_ReapSemMem, sizeof(s_ReapSemMem), 0U, 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);
            }
        }
        stk_critical_section_exit();
    }
}

References ReaperEntry(), s_BoundKernel, s_ReaperStack, s_ReaperTask, s_ReapSem, s_ReapSemMem, STK_C_ASSERT, STK_C_PTHREAD_REAPER_STACK_WORDS, stk_critical_section_enter(), stk_critical_section_exit(), stk_kernel_add_task(), stk_sem_create(), stk_task_create_user(), and stk_task_set_name().

Referenced by MaybeReap(), and pthread_create().

Here is the call graph for this function:

Here is the caller graph for this function:

EnsureRWLock()

stk_rwmutex_t * anonymous_namespace{stk_c_pthread.cpp}::EnsureRWLock

(

pthread_rwlock_t *

rw

)

Definition at line 367 of file stk_c_pthread.cpp.

{
    if (rw->__handle == nullptr)
    {
        stk_critical_section_enter();
        if (rw->__handle == nullptr)
        {
            rw->__handle = stk_rwmutex_create(&rw->__mem, sizeof(rw->__mem));
        }
        stk_critical_section_exit();
    }
 
    return rw->__handle;
}

References pthread_rwlock_t::__handle, pthread_rwlock_t::__mem, stk_critical_section_enter(), stk_critical_section_exit(), and stk_rwmutex_create().

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 * anonymous_namespace{stk_c_pthread.cpp}::EnsureStackPool

(

)

Definition at line 76 of file stk_c_pthread.cpp.

{
    if (s_StackPool == nullptr)
    {
        stk_critical_section_enter();
        if (s_StackPool == nullptr)
        {
            s_StackPool = stk_blockpool_create_static(
                STK_C_PTHREAD_MAX_THREADS,
                kDefaultStackBytes,
                reinterpret_cast<uint8_t *>(s_PthreadStackStorage),
                sizeof(s_PthreadStackStorage),
                "pthread_stacks");
        }
        stk_critical_section_exit();
    }
 
    return s_StackPool;
}

References kDefaultStackBytes, s_StackPool, stk_blockpool_create_static(), STK_C_PTHREAD_MAX_THREADS, stk_critical_section_enter(), and stk_critical_section_exit().

Referenced by pthread_create().

Here is the call graph for this function:

Here is the caller graph for this function:

MaybeReap()

void anonymous_namespace{stk_c_pthread.cpp}::MaybeReap

(

ThreadCtrl *

ctrl

)

Definition at line 186 of file stk_c_pthread.cpp.

{
    bool do_reap = false;
 
    stk_critical_section_enter();
    if (ctrl->finished && ctrl->detached && !ctrl->reclaimed)
    {
        ctrl->reclaimed = true;
        do_reap = true;
    }
    stk_critical_section_exit();
 
    if (do_reap)
    {
        EnsureReaper();
        EnqueueReap(ctrl);
        stk_sem_signal(s_ReapSem);
    }
}

References pthread_stk_ctrl_t::detached, EnqueueReap(), EnsureReaper(), pthread_stk_ctrl_t::finished, pthread_stk_ctrl_t::reclaimed, s_ReapSem, stk_critical_section_enter(), stk_critical_section_exit(), and stk_sem_signal().

Referenced by pthread_detach(), pthread_exit(), and PthreadTrampoline().

Here is the call graph for this function:

Here is the caller graph for this function:

PthreadTrampoline()

void anonymous_namespace{stk_c_pthread.cpp}::PthreadTrampoline

(

void *

arg

)

Definition at line 288 of file stk_c_pthread.cpp.

{
    ThreadCtrl *const ctrl = static_cast<ThreadCtrl *>(arg);
 
    stk_tls_set(ctrl);
 
    void *const result = ctrl->start_routine(ctrl->arg);
 
    RunKeyDestructors(ctrl);
 
    stk_critical_section_enter();
    ctrl->retval   = result;
    ctrl->finished = true;
    stk_critical_section_exit();
 
    stk_event_set(ctrl->done_event);
    MaybeReap(ctrl);
 
    // Natural return: STK finishes/frees the underlying dynamic task automatically.
    // A joiner (or the reaper, for detached threads) reclaims *our* resources
    // (stack, control block) only after confirming via WaitForTaskGone() that this
    // task has fully left the kernel's task list.
}

References pthread_stk_ctrl_t::arg, pthread_stk_ctrl_t::done_event, pthread_stk_ctrl_t::finished, MaybeReap(), pthread_stk_ctrl_t::retval, RunKeyDestructors(), pthread_stk_ctrl_t::start_routine, stk_critical_section_enter(), stk_critical_section_exit(), stk_event_set(), and stk_tls_set().

Referenced by pthread_create().

Here is the call graph for this function:

Here is the caller graph for this function:

ReaperEntry()

void anonymous_namespace{stk_c_pthread.cpp}::ReaperEntry

(

void *

arg

)

Definition at line 167 of file stk_c_pthread.cpp.

{
    for (;;)
    {
        STK_C_ASSERT(s_ReapSem != nullptr);
        stk_sem_wait(s_ReapSem, STK_WAIT_INFINITE);
 
        ThreadCtrl *ctrl = DequeueReap();
        if (ctrl != nullptr)
        {
            WaitForTaskGone(ctrl->task);
            ReleaseThreadResources(ctrl);
        }
    }
}

References DequeueReap(), ReleaseThreadResources(), s_ReapSem, STK_C_ASSERT, stk_sem_wait(), STK_WAIT_INFINITE, pthread_stk_ctrl_t::task, and WaitForTaskGone().

Referenced by EnsureReaper().

Here is the call graph for this function:

Here is the caller graph for this function:

ReleaseThreadResources()

void anonymous_namespace{stk_c_pthread.cpp}::ReleaseThreadResources

(

ThreadCtrl *

ctrl

)

Definition at line 259 of file stk_c_pthread.cpp.

{
    if (ctrl->done_event != nullptr)
    {
        stk_event_destroy(ctrl->done_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;
 
    stk_critical_section_enter();
    ctrl->busy = false;
    stk_critical_section_exit();
}

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(), stk_critical_section_enter(), stk_critical_section_exit(), and stk_event_destroy().

Referenced by pthread_join(), and ReaperEntry().

Here is the call graph for this function:

Here is the caller graph for this function:

RunKeyDestructors()

void anonymous_namespace{stk_c_pthread.cpp}::RunKeyDestructors

(

ThreadCtrl *

ctrl

)

Definition at line 415 of file stk_c_pthread.cpp.

{
    for (int iter = 0; 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) { continue; }
 
            void (*destructor)(void *) = nullptr;
            stk_critical_section_enter();
            if (s_Keys[i].used) { destructor = s_Keys[i].destructor; }
            stk_critical_section_exit();
 
            ctrl->tsd[i] = nullptr; // clear before calling, per POSIX
            if (destructor != nullptr)
            {
                destructor(value);
                any_ran = true;
            }
        }
 
        if (!any_ran) { break; }
    }
}

References PTHREAD_DESTRUCTOR_ITERATIONS, s_Keys, STK_C_PTHREAD_KEYS_MAX, stk_critical_section_enter(), stk_critical_section_exit(), and pthread_stk_ctrl_t::tsd.

Referenced by pthread_exit(), and PthreadTrampoline().

Here is the call graph for this function:

Here is the caller graph for this function:

STK_BLOCKPOOL_STORAGE_DECL()

anonymous_namespace{stk_c_pthread.cpp}::STK_BLOCKPOOL_STORAGE_DECL	(	s_PthreadStackStorage	,
		(8U)	,
		kDefaultStackBytes	)

References kDefaultStackBytes, and STK_C_PTHREAD_MAX_THREADS.

TimespecToRelativeTimeout()

stk_timeout_t anonymous_namespace{stk_c_pthread.cpp}::TimespecToRelativeTimeout

(

const struct timespec *

abstime

)

Definition at line 318 of file stk_c_pthread.cpp.

{
    const stk_time_t now_ms    = stk_time_now_ms();
    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;
    }
    if (rel_ms > static_cast<stk_time_t>(INT32_MAX))
    {
        rel_ms = static_cast<stk_time_t>(INT32_MAX);
    }
 
    return stk_ticks_from_ms_clamped_to_timeout(static_cast<stk_timeout_t>(rel_ms));
}

References stk_ticks_from_ms_clamped_to_timeout(), and stk_time_now_ms().

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:

WaitForTaskGone()

void anonymous_namespace{stk_c_pthread.cpp}::WaitForTaskGone

(

stk_task_t *

task

)

Definition at line 232 of file stk_c_pthread.cpp.

{
    stk_task_t *buf[STK_C_KERNEL_MAX_TASKS];
 
    for (;;)
    {
        const std::size_t n = stk_kernel_enumerate_tasks(s_BoundKernel, buf, STK_C_KERNEL_MAX_TASKS);
 
        bool found = false;
        for (std::size_t i = 0U; i < n; ++i)
        {
            if (buf[i] == task)
            {
                found = true;
                break;
            }
        }
 
        if (!found)
        {
            break;
        }
 
        stk_sleep_ms(1);
    }
}

References s_BoundKernel, STK_C_KERNEL_MAX_TASKS, stk_kernel_enumerate_tasks(), and stk_sleep_ms().

Referenced by pthread_join(), and ReaperEntry().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

kDefaultStackBytes

std::size_t anonymous_namespace{stk_c_pthread.cpp}::kDefaultStackBytes

constexpr

Initial value:

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

Definition at line 60 of file stk_c_pthread.cpp.

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

s_BoundKernel

stk_kernel_t* anonymous_namespace{stk_c_pthread.cpp}::s_BoundKernel = nullptr

Definition at line 68 of file stk_c_pthread.cpp.

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

s_Keys

KeyEntry anonymous_namespace{stk_c_pthread.cpp}::s_Keys[(8U)]

Definition at line 406 of file stk_c_pthread.cpp.

Referenced by pthread_getspecific(), pthread_key_create(), pthread_key_delete(), pthread_setspecific(), and RunKeyDestructors().

s_ReapCount

std::size_t anonymous_namespace{stk_c_pthread.cpp}::s_ReapCount = 0U

Definition at line 101 of file stk_c_pthread.cpp.

Referenced by DequeueReap(), and EnqueueReap().

s_ReaperStack

stk_word_t anonymous_namespace{stk_c_pthread.cpp}::s_ReaperStack[(256U)]

Definition at line 106 of file stk_c_pthread.cpp.

Referenced by EnsureReaper().

s_ReaperTask

stk_task_t* anonymous_namespace{stk_c_pthread.cpp}::s_ReaperTask = nullptr

Definition at line 105 of file stk_c_pthread.cpp.

Referenced by EnsureReaper().

s_ReapHead

std::size_t anonymous_namespace{stk_c_pthread.cpp}::s_ReapHead = 0U

Definition at line 100 of file stk_c_pthread.cpp.

Referenced by DequeueReap(), and EnqueueReap().

s_ReapQueue

ThreadCtrl* anonymous_namespace{stk_c_pthread.cpp}::s_ReapQueue[(8U)]

Definition at line 99 of file stk_c_pthread.cpp.

Referenced by DequeueReap(), and EnqueueReap().

s_ReapSem

stk_sem_t* anonymous_namespace{stk_c_pthread.cpp}::s_ReapSem = nullptr

Definition at line 103 of file stk_c_pthread.cpp.

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

s_ReapSemMem

stk_sem_mem_t anonymous_namespace{stk_c_pthread.cpp}::s_ReapSemMem

Definition at line 104 of file stk_c_pthread.cpp.

Referenced by EnsureReaper().

s_StackPool

stk_blockpool_t* anonymous_namespace{stk_c_pthread.cpp}::s_StackPool = nullptr

Definition at line 74 of file stk_c_pthread.cpp.

Referenced by EnsureStackPool(), pthread_create(), and ReleaseThreadResources().

s_Threads

ThreadCtrl anonymous_namespace{stk_c_pthread.cpp}::s_Threads[(8U)]

Definition at line 63 of file stk_c_pthread.cpp.

Referenced by AcquireThreadSlot().