|
| void * | malloc (std::size_t size) |
| void | free (void *ptr) |
| | anonymous_namespace{stk_c_pthread.cpp}::STK_BLOCKPOOL_STORAGE_DECL (s_PthreadStackStorage,(8U), kDefaultStackBytes) |
| stk_blockpool_t * | anonymous_namespace{stk_c_pthread.cpp}::EnsureStackPool () |
| void | anonymous_namespace{stk_c_pthread.cpp}::ReleaseThreadResources (ThreadCtrl *ctrl) |
| void | anonymous_namespace{stk_c_pthread.cpp}::WaitForTaskGone (stk_task_t *task) |
| void | anonymous_namespace{stk_c_pthread.cpp}::ReaperEntry (void *arg) |
| void | anonymous_namespace{stk_c_pthread.cpp}::EnsureReaper () |
| void | anonymous_namespace{stk_c_pthread.cpp}::EnqueueReap (ThreadCtrl *ctrl) |
| ThreadCtrl * | anonymous_namespace{stk_c_pthread.cpp}::DequeueReap () |
| void | anonymous_namespace{stk_c_pthread.cpp}::MaybeReap (ThreadCtrl *ctrl) |
| ThreadCtrl * | anonymous_namespace{stk_c_pthread.cpp}::AcquireThreadSlot () |
| void | anonymous_namespace{stk_c_pthread.cpp}::PthreadTrampoline (void *arg) |
| stk_timeout_t | anonymous_namespace{stk_c_pthread.cpp}::TimespecToRelativeTimeout (const struct timespec *abstime) |
| stk_mutex_t * | anonymous_namespace{stk_c_pthread.cpp}::EnsureMutex (pthread_mutex_t *m) |
| stk_cv_t * | anonymous_namespace{stk_c_pthread.cpp}::EnsureCond (pthread_cond_t *c) |
| stk_rwmutex_t * | anonymous_namespace{stk_c_pthread.cpp}::EnsureRWLock (pthread_rwlock_t *rw) |
| stk_mutex_t * | anonymous_namespace{stk_c_pthread.cpp}::EnsureOnceMutex (pthread_once_t *o) |
| void | anonymous_namespace{stk_c_pthread.cpp}::RunKeyDestructors (ThreadCtrl *ctrl) |
| void | stk_pthread_bind_kernel (stk_kernel_t *kernel) |
| | Bind the STK kernel instance that pthread_create() will add new threads to.
|
| int | pthread_attr_init (pthread_attr_t *attr) |
| | Initialize a thread attributes object with default values (default stack size, no external stack, joinable).
|
| int | pthread_attr_destroy (pthread_attr_t *attr) |
| | Destroy a thread attributes object (no-op; no owned resources).
|
| int | pthread_attr_setstacksize (pthread_attr_t *attr, size_t stacksize) |
| | Set the requested stack size in bytes.
|
| int | pthread_attr_getstacksize (const pthread_attr_t *attr, size_t *stacksize) |
| | Get the currently requested stack size in bytes (0 = default).
|
| int | pthread_attr_setstack (pthread_attr_t *attr, void *stackaddr, size_t stacksize) |
| | Supply an external, caller-owned stack buffer for the thread.
|
| int | pthread_attr_getstack (const pthread_attr_t *attr, void **stackaddr, size_t *stacksize) |
| | Get the previously-set external stack (NULL/0 if none set).
|
| int | pthread_attr_setdetachstate (pthread_attr_t *attr, int detachstate) |
| | Set PTHREAD_CREATE_JOINABLE or PTHREAD_CREATE_DETACHED.
|
| int | pthread_attr_getdetachstate (const pthread_attr_t *attr, int *detachstate) |
| | Get the current detach-state setting.
|
| int | pthread_create (pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg) |
| | Create and start a new thread.
|
| int | pthread_join (pthread_t thread, void **retval) |
| | Block until the given joinable thread finishes, then reclaim its resources.
|
| int | pthread_detach (pthread_t thread) |
| | Mark a thread as detached.
|
| void | pthread_exit (void *retval) |
| | Terminate the calling thread.
|
| pthread_t | pthread_self (void) |
| | Return the calling thread's own handle.
|
| int | pthread_equal (pthread_t t1, pthread_t t2) |
| | Compare two thread handles for equality.
|
| int | pthread_yield (void) |
| | Voluntarily give up the CPU to another ready task (cooperative yield), then resume once rescheduled.
|
| int | pthread_mutexattr_init (pthread_mutexattr_t *attr) |
| int | pthread_mutexattr_destroy (pthread_mutexattr_t *attr) |
| int | pthread_mutexattr_settype (pthread_mutexattr_t *attr, int type) |
| | Set the mutex type.
|
| int | pthread_mutexattr_gettype (const pthread_mutexattr_t *attr, int *type) |
| int | pthread_mutex_init (pthread_mutex_t *mutex, const pthread_mutexattr_t *attr) |
| | Initialize a mutex.
|
| int | pthread_mutex_destroy (pthread_mutex_t *mutex) |
| int | pthread_mutex_lock (pthread_mutex_t *mutex) |
| int | pthread_mutex_trylock (pthread_mutex_t *mutex) |
| int | pthread_mutex_unlock (pthread_mutex_t *mutex) |
| int | pthread_mutex_timedlock (pthread_mutex_t *mutex, const struct timespec *abstime) |
| | Lock with an absolute deadline.
|
| int | pthread_condattr_init (pthread_condattr_t *attr) |
| int | pthread_condattr_destroy (pthread_condattr_t *attr) |
| int | pthread_cond_init (pthread_cond_t *cond, const pthread_condattr_t *) |
| int | pthread_cond_destroy (pthread_cond_t *cond) |
| int | pthread_cond_wait (pthread_cond_t *cond, pthread_mutex_t *mutex) |
| | Atomically unlock mutex and wait for a signal; re-locks mutex before returning.
|
| int | pthread_cond_timedwait (pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime) |
| | As pthread_cond_wait(), with an absolute deadline.
|
| int | pthread_cond_signal (pthread_cond_t *cond) |
| int | pthread_cond_broadcast (pthread_cond_t *cond) |
| int | pthread_rwlockattr_init (pthread_rwlockattr_t *attr) |
| int | pthread_rwlockattr_destroy (pthread_rwlockattr_t *attr) |
| int | pthread_rwlock_init (pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *) |
| | Initialize a read-write lock.
|
| int | pthread_rwlock_destroy (pthread_rwlock_t *rwlock) |
| int | pthread_rwlock_rdlock (pthread_rwlock_t *rwlock) |
| | Acquire the lock for shared reading. Blocks until available.
|
| int | pthread_rwlock_tryrdlock (pthread_rwlock_t *rwlock) |
| | Try to acquire the read lock without blocking.
|
| int | pthread_rwlock_timedrdlock (pthread_rwlock_t *rwlock, const struct timespec *abstime) |
| | Acquire the read lock with an absolute deadline.
|
| int | pthread_rwlock_wrlock (pthread_rwlock_t *rwlock) |
| | Acquire the lock for exclusive writing. Blocks until available.
|
| int | pthread_rwlock_trywrlock (pthread_rwlock_t *rwlock) |
| | Try to acquire the write lock without blocking.
|
| int | pthread_rwlock_timedwrlock (pthread_rwlock_t *rwlock, const struct timespec *abstime) |
| | Acquire the write lock with an absolute deadline.
|
| int | pthread_rwlock_unlock (pthread_rwlock_t *rwlock) |
| | Release a read or write hold, whichever the calling thread holds.
|
| int | pthread_spin_init (pthread_spinlock_t *lock, int pshared) |
| | Initialize a spinlock.
|
| int | pthread_spin_destroy (pthread_spinlock_t *lock) |
| int | pthread_spin_lock (pthread_spinlock_t *lock) |
| | Acquire the spinlock, spinning until available.
|
| int | pthread_spin_trylock (pthread_spinlock_t *lock) |
| | Try to acquire the spinlock without blocking.
|
| int | pthread_spin_unlock (pthread_spinlock_t *lock) |
| int | pthread_barrierattr_init (pthread_barrierattr_t *attr) |
| int | pthread_barrierattr_destroy (pthread_barrierattr_t *attr) |
| int | pthread_barrier_init (pthread_barrier_t *barrier, const pthread_barrierattr_t *, unsigned int count) |
| | Initialize a barrier for count participating threads.
|
| int | pthread_barrier_destroy (pthread_barrier_t *barrier) |
| int | pthread_barrier_wait (pthread_barrier_t *barrier) |
| | Block until count threads have called this function, then release them all together; the barrier resets for reuse.
|
| int | pthread_once (pthread_once_t *once_control, void(*init_routine)(void)) |
| | Call init_routine exactly once for a given once_control, no matter how many threads call pthread_once() on it concurrently.
|
| int | pthread_key_create (pthread_key_t *key, void(*destructor)(void *)) |
| | Allocate a new thread-specific data key.
|
| int | pthread_key_delete (pthread_key_t key) |
| | Free a thread-specific data key.
|
| int | pthread_setspecific (pthread_key_t key, const void *value) |
| | Set the calling thread's value for key.
|
| void * | pthread_getspecific (pthread_key_t key) |
| | Get the calling thread's value for key.
|
1.16.1 
