Persistent pthread thread pool for CK-Engine inference. More...

#include <stdint.h>
#include <stdatomic.h>
#include <pthread.h>

Data Structures
struct	ck_threadpool_profile_t

Macros
#define	CK_CACHE_LINE 64

#define	CK_THREADPOOL_MAX_THREADS 64

#define	CK_THREADPOOL_SPIN_COUNT 1024

Typedefs
typedef void(*	ck_range_fn_t) (int begin, int end, void *args)

typedef void(*	ck_work_fn_t) (int ith, int nth, void *args)

Enumerations
enum	ck_gemm_schedule_t { CK_GEMM_SCHEDULE_AUTO = 0 , CK_GEMM_SCHEDULE_STATIC = 1 , CK_GEMM_SCHEDULE_DYNAMIC = 2 }

Functions
int	ck_gemm_dynamic_schedule_enabled (void)

int	ck_get_gemm_schedule (void)

int	ck_set_gemm_schedule (int policy)

void	ck_threadpool_barrier (ck_threadpool_t *pool)

int	ck_threadpool_bounded_capacity (int default_threads, int logical_threads)

int	ck_threadpool_capacity (const ck_threadpool_t *pool)

ck_threadpool_t *	ck_threadpool_create (int n_threads)

ck_threadpool_t *	ck_threadpool_create_capacity (int default_threads, int capacity_threads)

void	ck_threadpool_destroy (ck_threadpool_t *pool)

void	ck_threadpool_dispatch (ck_threadpool_t pool, ck_work_fn_t fn, void args)

void	ck_threadpool_dispatch_n (ck_threadpool_t pool, int active_threads, ck_work_fn_t fn, void args)

ck_threadpool_t *	ck_threadpool_global (void)

void	ck_threadpool_global_destroy (void)

int	ck_threadpool_n_threads (const ck_threadpool_t *pool)

void	ck_threadpool_parallel_for_n (ck_threadpool_t pool, int active_threads, int begin, int end, int grain_size, ck_range_fn_t fn, void args)

void	ck_threadpool_pause (ck_threadpool_t *pool)

void	ck_threadpool_profile_reset (ck_threadpool_t *pool)

void	ck_threadpool_profile_snapshot (const ck_threadpool_t pool, ck_threadpool_profile_t profile)

void	ck_threadpool_resume (ck_threadpool_t *pool)

int	ck_threadpool_thread_id (const ck_threadpool_t *pool)

Detailed Description

Persistent pthread thread pool for CK-Engine inference.

Design goals:

Sub-microsecond dispatch latency (spin-wait barriers)
Zero allocation after init (all memory pre-allocated)
Cache-line aligned atomics to avoid false sharing
Hybrid polling: spin N rounds, then fall back to condvar
Thread 0 = calling thread (does serial ops + its share of parallel work)

Usage: ck_threadpool_t *pool = ck_threadpool_create(4); // 4 threads total

// In decode loop: ck_threadpool_dispatch(pool, my_work_fn, args); // my_work_fn called on all threads with (ith, nth, args)

// Between batches: ck_threadpool_pause(pool); // workers sleep (0% CPU) ck_threadpool_resume(pool); // wake workers

ck_threadpool_destroy(pool);

Architecture: STARTUP: Main creates N-1 worker pthreads, all spin on atomic counter DISPATCH: Main writes work desc, bumps counter, all threads execute BARRIER: Atomic counter + spin-wait with _mm_pause() PAUSE: Workers sleep on pthread_cond_t (0% CPU between batches)

Definition in file ck_threadpool.h.

Macro Definition Documentation

◆ CK_CACHE_LINE

#define CK_CACHE_LINE 64

Cache line size for alignment (x86-64)

Definition at line 54 of file ck_threadpool.h.

◆ CK_THREADPOOL_MAX_THREADS

#define CK_THREADPOOL_MAX_THREADS 64

Maximum threads supported (main + workers)

Definition at line 48 of file ck_threadpool.h.

◆ CK_THREADPOOL_SPIN_COUNT

#define CK_THREADPOOL_SPIN_COUNT 1024

Number of spin iterations before falling back to condvar wait

Definition at line 51 of file ck_threadpool.h.

Typedef Documentation

◆ ck_range_fn_t

typedef void(* ck_range_fn_t) (int begin, int end, void *args)

Process the half-open interval [begin, end).

Definition at line 86 of file ck_threadpool.h.

◆ ck_work_fn_t

typedef void(* ck_work_fn_t) (int ith, int nth, void *args)

Work function signature. Called on ALL threads (including calling thread 0).

Parameters

ith	Thread index (0 = calling thread)
nth	Total number of threads
args	Opaque argument pointer (set via dispatch)

Definition at line 68 of file ck_threadpool.h.

Enumeration Type Documentation

◆ ck_gemm_schedule_t

enum ck_gemm_schedule_t

Scheduling policy for independent GEMM output tiles.

Enumerator
CK_GEMM_SCHEDULE_AUTO
CK_GEMM_SCHEDULE_STATIC
CK_GEMM_SCHEDULE_DYNAMIC

Definition at line 89 of file ck_threadpool.h.

             {
    CK_GEMM_SCHEDULE_AUTO = 0,
    CK_GEMM_SCHEDULE_STATIC = 1,
    CK_GEMM_SCHEDULE_DYNAMIC = 2,
} ck_gemm_schedule_t;

Function Documentation

◆ ck_gemm_dynamic_schedule_enabled()

int ck_gemm_dynamic_schedule_enabled ( void )

Return non-zero when independent GEMM tiles should use dynamic claiming.

Definition at line 55 of file ck_threadpool.c.

{
    const int policy = ck_get_gemm_schedule();
    return policy == CK_GEMM_SCHEDULE_AUTO || policy == CK_GEMM_SCHEDULE_DYNAMIC;
}

References CK_GEMM_SCHEDULE_AUTO, CK_GEMM_SCHEDULE_DYNAMIC, and ck_get_gemm_schedule().

Referenced by gemm_nt_q4_k_packed_vnni_x8_q8_k_split_min_threaded_4m().

◆ ck_get_gemm_schedule()

int ck_get_gemm_schedule ( void )

Return the configured process-wide GEMM scheduling policy.

Definition at line 50 of file ck_threadpool.c.

{
    return atomic_load_explicit(&g_gemm_schedule, memory_order_acquire);
}

References g_gemm_schedule.

Referenced by ck_gemm_dynamic_schedule_enabled().

◆ ck_set_gemm_schedule()

int ck_set_gemm_schedule ( int policy )

Set the process-wide GEMM tile scheduling policy.

AUTO is the production default and currently selects dynamic work claiming for providers whose jobs write independent output tiles. Providers with ordered/shared reductions do not consult this policy.

Returns: 0 on success, -1 for an invalid policy.

Definition at line 41 of file ck_threadpool.c.

{
    if (policy < CK_GEMM_SCHEDULE_AUTO || policy > CK_GEMM_SCHEDULE_DYNAMIC) {
        return -1;
    }
    atomic_store_explicit(&g_gemm_schedule, policy, memory_order_release);
    return 0;
}

References CK_GEMM_SCHEDULE_DYNAMIC, and g_gemm_schedule.

◆ ck_threadpool_barrier()

void ck_threadpool_barrier ( ck_threadpool_t * pool )

Barrier synchronization within a dispatched work function.

ALL participants in the current dispatch must call this at the same point. A single-worker dispatch returns immediately, even if the pool has more workers or another caller is executing a multi-worker dispatch.

Must only be called from within a work function (during dispatch).

Parameters

pool	Thread pool

Definition at line 549 of file ck_threadpool.c.

{
    /* Only participants in this multi-worker dispatch use its barrier.
     * In particular, an overlapping single-worker callback must never touch
     * the shared barrier belonging to a different dispatch. */
    if (!pool || g_dispatch_context.pool != pool ||
        g_dispatch_context.nth <= 1) return;
    barrier_wait(&pool->barrier);
}

References barrier_wait(), and g_dispatch_context.

◆ ck_threadpool_bounded_capacity()

int ck_threadpool_bounded_capacity	(	int	default_threads,
		int	logical_threads
	)

Compute the bounded capacity for an SMT-safe provider. The default width is preserved and at most half of the additional logical CPUs are reserved.

Definition at line 277 of file ck_threadpool.c.

{
    if (default_threads < 1) default_threads = 1;
    if (default_threads > CK_THREADPOOL_MAX_THREADS) {
        default_threads = CK_THREADPOOL_MAX_THREADS;
    }
    if (logical_threads <= default_threads) return default_threads;
 
    int capacity = default_threads + (logical_threads - default_threads) / 2;
    if (capacity > CK_THREADPOOL_MAX_THREADS) {
        capacity = CK_THREADPOOL_MAX_THREADS;
    }
    return capacity;
}

References CK_THREADPOOL_MAX_THREADS.

Referenced by global_pool_init().

◆ ck_threadpool_capacity()

int ck_threadpool_capacity ( const ck_threadpool_t * pool )

Get the maximum worker capacity available to explicit dispatch_n calls.

Definition at line 589 of file ck_threadpool.c.

{
    return pool ? pool->n_threads : 1;
}

Referenced by gemm_nt_q4_k_packed_vnni_x16_q8_k_split_min_threaded_16m(), and gemm_nt_q4_k_packed_vnni_x8_q8_k_split_min_threaded_4m().

◆ ck_threadpool_create()

ck_threadpool_t * ck_threadpool_create ( int n_threads )

Create a thread pool with n_threads total threads. Thread 0 is the calling thread; n_threads-1 workers are spawned.

Parameters

n_threads Total thread count (including main). Must be >= 1. Pass 0 for auto-detect (physical cores).

Returns: Pool handle, or NULL on failure.

Definition at line 364 of file ck_threadpool.c.

{
    return ck_threadpool_create_capacity(n_threads, n_threads);
}

References ck_threadpool_create_capacity().

◆ ck_threadpool_create_capacity()

ck_threadpool_t * ck_threadpool_create_capacity	(	int	default_threads,
		int	capacity_threads
	)

Create a pool whose ordinary dispatch width is smaller than its worker capacity. Exact providers may opt into the additional workers with ck_threadpool_dispatch_n(); ordinary dispatch remains at default_threads.

Definition at line 292 of file ck_threadpool.c.

{
    if (default_threads <= 0) {
        default_threads = ck_get_physical_cores();
        if (default_threads <= 0) default_threads = 1;
        /* Cap at reasonable default for memory-bound workloads */
        if (default_threads > 8) default_threads = 8;
    }
    if (capacity_threads < default_threads) {
        capacity_threads = default_threads;
    }
    if (capacity_threads > CK_THREADPOOL_MAX_THREADS) {
        capacity_threads = CK_THREADPOOL_MAX_THREADS;
    }
    if (default_threads > capacity_threads) {
        default_threads = capacity_threads;
    }
 
    ck_threadpool_t *pool = aligned_alloc(CK_CACHE_LINE, sizeof(ck_threadpool_t));
    if (!pool) return NULL;
    memset(pool, 0, sizeof(*pool));
 
    pool->n_threads = capacity_threads;
    pool->default_threads = default_threads;
    atomic_store(&pool->n_dispatch, 0);
    atomic_store(&pool->n_complete, 0);
    atomic_store(&pool->active_threads, default_threads);
    atomic_store(&pool->stop, 0);
    atomic_store(&pool->paused, 0);
    atomic_store(&pool->profile_enabled, 0);
    pool->work_fn = NULL;
    pool->work_args = NULL;
 
    barrier_init(&pool->barrier, default_threads);
 
    pthread_mutex_init(&pool->dispatch_mutex, NULL);
    pthread_mutex_init(&pool->mutex, NULL);
    pthread_cond_init(&pool->cond_dispatch, NULL);
    pthread_cond_init(&pool->cond_done, NULL);
 
    /* Slot 0 runs on the dispatch caller (no worker pthread created). */
    pool->workers[0].id = 0;
    pool->workers[0].pool = pool;
    pool->workers[0].thread = pthread_self();
 
    /* Spawn N-1 worker threads */
    for (int i = 1; i < capacity_threads; i++) {
        pool->workers[i].id = i;
        pool->workers[i].pool = pool;
 
        int rc = pthread_create(&pool->workers[i].thread, NULL,
                                worker_main, &pool->workers[i]);
        if (rc != 0) {
            fprintf(stderr, "[CK threadpool] Failed to create worker %d: %s\n",
                    i, strerror(rc));
            /* Reduce thread count to what we managed to create */
            pool->n_threads = i;
            barrier_init(&pool->barrier, i);
            break;
        }
    }
 
    if (pool->n_threads > 1) {
        fprintf(stderr,
                "[CK threadpool] Created %d threads (default=%d, 1 main + %d workers)\n",
                pool->n_threads, pool->default_threads, pool->n_threads - 1);
    }
 
    return pool;
}

References barrier_init(), CK_CACHE_LINE, ck_get_physical_cores(), CK_THREADPOOL_MAX_THREADS, and worker_main().

Referenced by ck_threadpool_create(), and global_pool_init().

◆ ck_threadpool_destroy()

void ck_threadpool_destroy ( ck_threadpool_t * pool )

Destroy the thread pool. Signals all workers to exit and joins them. Safe to call with NULL.

Definition at line 369 of file ck_threadpool.c.

{
    if (!pool) return;
 
    /* Signal shutdown */
    atomic_store_explicit(&pool->stop, 1, memory_order_release);
 
    /* Wake all sleeping workers */
    pthread_mutex_lock(&pool->mutex);
    pthread_cond_broadcast(&pool->cond_dispatch);
    pthread_mutex_unlock(&pool->mutex);
 
    /* Join all worker threads */
    for (int i = 1; i < pool->n_threads; i++) {
        pthread_join(pool->workers[i].thread, NULL);
    }
 
    pthread_cond_destroy(&pool->cond_dispatch);
    pthread_cond_destroy(&pool->cond_done);
    pthread_mutex_destroy(&pool->mutex);
    pthread_mutex_destroy(&pool->dispatch_mutex);
 
    free(pool);
}

Referenced by ck_threadpool_global_destroy().

◆ ck_threadpool_dispatch()

void ck_threadpool_dispatch	(	ck_threadpool_t *	pool,
		ck_work_fn_t	fn,
		void *	args
	)

Dispatch work to all threads and wait for completion.

Sets the work function and args
Bumps the dispatch counter (wakes workers)
Main thread (ith=0) executes its share
Waits for all worker callbacks to complete

This is a blocking call — returns when ALL threads have finished. Concurrent multi-worker dispatches on the same pool are serialized. Single-worker calls may execute concurrently because they do not publish a shared work descriptor. Do not destroy a pool while a call is active or recursively dispatch the same pool from one of its work functions.

Parameters

pool	Thread pool
fn	Work function (called on each thread)
args	Argument passed to fn

Definition at line 494 of file ck_threadpool.c.

{
    if (!pool) return;
    ck_threadpool_dispatch_n(pool, pool->default_threads, fn, args);
}

References ck_threadpool_dispatch_n().

◆ ck_threadpool_dispatch_n()

void ck_threadpool_dispatch_n	(	ck_threadpool_t *	pool,
		int	active_threads,
		ck_work_fn_t	fn,
		void *	args
	)

Dispatch work to a subset of the pool and wait for completion.

Threads with ith >= active_threads remain idle for this dispatch. The work function sees nth == active_threads.

Parameters

pool	Thread pool
active_threads	Number of active threads including the calling thread
fn	Work function
args	Argument passed to fn

Definition at line 398 of file ck_threadpool.c.

{
    if (!pool || !fn) return;
    if (active_threads <= 0) {
        active_threads = 1;
    }
    if (active_threads > pool->n_threads) {
        active_threads = pool->n_threads;
    }
 
    const int profile = atomic_load_explicit(
        &pool->profile_enabled, memory_order_relaxed);
    const uint64_t dispatch_start = profile ? monotonic_ns() : 0;
 
    /* Single-thread fast path: just call directly */
    if (active_threads == 1 || pool->n_threads == 1) {
        run_work(pool, fn, 0, 1, args);
        if (profile) {
            const uint64_t dispatch_end = monotonic_ns();
            atomic_fetch_add_explicit(&pool->profile_dispatch_count, 1, memory_order_relaxed);
            atomic_fetch_add_explicit(
                &pool->profile_dispatch_total_ns,
                dispatch_end - dispatch_start,
                memory_order_relaxed);
            atomic_fetch_add_explicit(
                &pool->profile_main_work_ns,
                dispatch_end - dispatch_start,
                memory_order_relaxed);
        }
        return;
    }
 
    /* The work descriptor and completion counter belong to one dispatch.
     * Concurrent callers may share a pool, but their multi-worker dispatches
     * must not overwrite one another's descriptor or barrier state. */
    pthread_mutex_lock(&pool->dispatch_mutex);
 
    /* Reset barrier phase for this dispatch */
    barrier_init(&pool->barrier, active_threads);
 
    /* Set work descriptor */
    pthread_mutex_lock(&pool->mutex);
    pool->work_fn = fn;
    pool->work_args = args;
    atomic_store_explicit(&pool->active_threads, active_threads, memory_order_release);
    atomic_store_explicit(&pool->n_complete, 0, memory_order_release);
 
    /* Wake workers by bumping dispatch counter */
    atomic_fetch_add_explicit(&pool->n_dispatch, 1, memory_order_release);
 
    /* Also signal condvar for sleeping workers */
    pthread_cond_broadcast(&pool->cond_dispatch);
    pthread_mutex_unlock(&pool->mutex);
 
    /* Main thread (ith=0) does its share */
    const uint64_t main_start = profile ? monotonic_ns() : 0;
    run_work(pool, fn, 0, active_threads, args);
    const uint64_t main_end = profile ? monotonic_ns() : 0;
 
    /* Wait for all workers to complete */
    if (active_threads > 1) {
        int spins = 0;
        while (atomic_load_explicit(&pool->n_complete, memory_order_acquire)
               < active_threads - 1) {
            CK_SPIN_PAUSE();
            spins++;
            if (spins >= CK_THREADPOOL_SPIN_COUNT) {
                pthread_mutex_lock(&pool->mutex);
                if (atomic_load_explicit(&pool->n_complete, memory_order_acquire)
                    < active_threads - 1) {
                    pthread_cond_wait(&pool->cond_done, &pool->mutex);
                }
                pthread_mutex_unlock(&pool->mutex);
                spins = 0;
            }
        }
    }
    if (profile) {
        const uint64_t dispatch_end = monotonic_ns();
        atomic_fetch_add_explicit(&pool->profile_dispatch_count, 1, memory_order_relaxed);
        atomic_fetch_add_explicit(
            &pool->profile_dispatch_total_ns,
            dispatch_end - dispatch_start,
            memory_order_relaxed);
        atomic_fetch_add_explicit(
            &pool->profile_main_work_ns,
            main_end - main_start,
            memory_order_relaxed);
        atomic_fetch_add_explicit(
            &pool->profile_completion_wait_ns,
            dispatch_end - main_end,
            memory_order_relaxed);
    }
    pthread_mutex_unlock(&pool->dispatch_mutex);
}

References barrier_init(), CK_SPIN_PAUSE, CK_THREADPOOL_SPIN_COUNT, monotonic_ns(), and run_work().

◆ ck_threadpool_global()

ck_threadpool_t * ck_threadpool_global ( void )

Get or create the global thread pool. Thread-safe (uses pthread_once internally). Uses ck_get_num_threads() for the default width. In automatic mode the pool may reserve a bounded subset of SMT siblings as explicit provider capacity; ordinary dispatch remains at the default width.

Returns: Global pool, never NULL after successful first call.

Definition at line 685 of file ck_threadpool.c.

{
    pthread_once(&g_threadpool_once, global_pool_init);
    return g_threadpool;
}

References g_threadpool, g_threadpool_once, and global_pool_init().

◆ ck_threadpool_global_destroy()

void ck_threadpool_global_destroy ( void )

Destroy the global thread pool. Called during engine shutdown.

Definition at line 691 of file ck_threadpool.c.

{
    if (g_threadpool) {
        ck_threadpool_destroy(g_threadpool);
        g_threadpool = NULL;
        /* Reset once control so pool can be re-created if needed */
        g_threadpool_once = PTHREAD_ONCE_INIT;
    }
}

References ck_threadpool_destroy(), g_threadpool, and g_threadpool_once.

Referenced by ck_threadpool_shutdown().

◆ ck_threadpool_n_threads()

int ck_threadpool_n_threads ( const ck_threadpool_t * pool )

Get the ordinary/default dispatch width (including the calling thread).

Definition at line 584 of file ck_threadpool.c.

{
    return pool ? pool->default_threads : 1;
}

◆ ck_threadpool_parallel_for_n()

void ck_threadpool_parallel_for_n	(	ck_threadpool_t *	pool,
		int	active_threads,
		int	begin,
		int	end,
		int	grain_size,
		ck_range_fn_t	fn,
		void *	args
	)

Dynamically distribute independent ranges through the persistent pool.

Workers claim grain_size consecutive indices until [begin, end) is empty. This changes ownership only; callers remain responsible for ensuring that ranges write disjoint outputs and preserve each output's reduction order. Do not use this helper for unordered shared reductions.

Definition at line 523 of file ck_threadpool.c.

{
    if (!fn || begin >= end) return;
    if (grain_size <= 0) grain_size = 1;
    if (!pool || active_threads <= 1) {
        fn(begin, end, args);
        return;
    }
 
    ck_parallel_for_work_t work = {
        .end = end,
        .grain_size = grain_size,
        .fn = fn,
        .args = args,
    };
    atomic_init(&work.next, begin);
    ck_threadpool_dispatch_n(
        pool, active_threads, ck_parallel_for_worker, &work);
}

References ck_parallel_for_worker(), ck_threadpool_dispatch_n(), and end.

Referenced by attn_gate_sigmoid_mul_forward(), audio_conformer_relative_attention_f32(), audio_conv2d_whc_grouped_f32(), audio_glu_split_channel_major_f32(), audio_relative_shift_f32(), ck_gemma4_prepare_parallel(), ck_swiglu_dispatch_rows(), deepseek_mla_kv_decompress_bf16_parallel_dispatch(), gemm_nt_bf16_accurate_storage_parallel_dispatch(), gemm_nt_bf16_bf16_storage_parallel_dispatch(), gemm_nt_bf16_parallel_dispatch(), gemm_nt_fp32_exact_parallel_dispatch(), gemm_nt_q4_k_packed_vnni_x8_q8_k_split_min_threaded_4m(), gemma4_per_layer_embed_forward(), gemv_bf16_bf16_storage_parallel_dispatch(), gemv_bf16_parallel_dispatch(), gemv_nvfp4_q8_0_uniform(), recurrent_conv_state_update_forward(), recurrent_qk_l2_norm_forward(), recurrent_silu_forward_ggml(), ssm_conv1d_forward_llama_fma(), and ssm_conv1d_forward_llama_production().

◆ ck_threadpool_pause()

void ck_threadpool_pause ( ck_threadpool_t * pool )

Pause workers — they sleep on condvar (0% CPU). Call between batches or during interactive waiting. Workers wake on next dispatch or resume.

Definition at line 563 of file ck_threadpool.c.

{
    if (!pool) return;
    atomic_store_explicit(&pool->paused, 1, memory_order_release);
}

◆ ck_threadpool_profile_reset()

void ck_threadpool_profile_reset ( ck_threadpool_t * pool )

Enable profiling and reset cumulative dispatch timing counters.

Definition at line 607 of file ck_threadpool.c.

{
    if (!pool) return;
    atomic_store_explicit(&pool->profile_dispatch_count, 0, memory_order_relaxed);
    atomic_store_explicit(&pool->profile_dispatch_total_ns, 0, memory_order_relaxed);
    atomic_store_explicit(&pool->profile_main_work_ns, 0, memory_order_relaxed);
    atomic_store_explicit(&pool->profile_completion_wait_ns, 0, memory_order_relaxed);
    atomic_store_explicit(&pool->profile_enabled, 1, memory_order_release);
}

◆ ck_threadpool_profile_snapshot()

void ck_threadpool_profile_snapshot	(	const ck_threadpool_t *	pool,
		ck_threadpool_profile_t *	profile
	)

Snapshot cumulative dispatch timing counters without stopping workers.

Definition at line 617 of file ck_threadpool.c.

{
    if (!profile) return;
    memset(profile, 0, sizeof(*profile));
    if (!pool) return;
    profile->dispatch_count = atomic_load_explicit(
        &pool->profile_dispatch_count, memory_order_relaxed);
    profile->dispatch_total_ns = atomic_load_explicit(
        &pool->profile_dispatch_total_ns, memory_order_relaxed);
    profile->main_work_ns = atomic_load_explicit(
        &pool->profile_main_work_ns, memory_order_relaxed);
    profile->completion_wait_ns = atomic_load_explicit(
        &pool->profile_completion_wait_ns, memory_order_relaxed);
}

References ck_threadpool_profile_t::completion_wait_ns, ck_threadpool_profile_t::dispatch_count, ck_threadpool_profile_t::dispatch_total_ns, and ck_threadpool_profile_t::main_work_ns.

◆ ck_threadpool_resume()

void ck_threadpool_resume ( ck_threadpool_t * pool )

Resume workers — transition from sleep to spin-wait. Call before starting a new batch of work.

Definition at line 569 of file ck_threadpool.c.

{
    if (!pool) return;
    atomic_store_explicit(&pool->paused, 0, memory_order_release);
 
    /* Wake sleeping workers */
    pthread_mutex_lock(&pool->mutex);
    pthread_cond_broadcast(&pool->cond_dispatch);
    pthread_mutex_unlock(&pool->mutex);
}

◆ ck_threadpool_thread_id()

int ck_threadpool_thread_id ( const ck_threadpool_t * pool )

Get the current callback's ith for this pool. Outside a callback, return the physical worker index (or the pool creator's legacy index 0), and -1 for an unrelated thread. The current dispatch caller is always index 0, including callers that did not create the pool.

Definition at line 594 of file ck_threadpool.c.

{
    if (!pool) return -1;
    if (g_dispatch_context.pool == pool) return g_dispatch_context.ith;
    pthread_t self = pthread_self();
    for (int i = 0; i < pool->n_threads; i++) {
        if (pthread_equal(self, pool->workers[i].thread)) {
            return i;
        }
    }
    return -1;
}

References g_dispatch_context.

Referenced by attention_forward_causal_head_major_gqa_prefill_append_bf16cache_pytorch_contract_workspace(), attention_forward_causal_head_major_gqa_prefill_append_f16cache_gqa_reuse_config(), attn_gate_sigmoid_mul_forward(), ck_attention_f16_prefill_qtile64_dispatch(), ck_attention_forward_causal_head_major_gqa_prefill_segmented_f16cache_schedule_workspace(), ck_audio_conformer_relative_attention_f32_row_range(), ck_sliding_attention_pick_threads(), ck_swiglu_dispatch_rows(), gelu_erf_fp64_f32_parallel_dispatch(), recurrent_conv_state_update_forward(), recurrent_qk_l2_norm_forward(), and recurrent_silu_forward_ggml().

Data Structures

Macros

Typedefs

Enumerations

Functions

Detailed Description

Macro Definition Documentation

◆ CK_CACHE_LINE

◆ CK_THREADPOOL_MAX_THREADS

◆ CK_THREADPOOL_SPIN_COUNT

Typedef Documentation

◆ ck_range_fn_t

◆ ck_work_fn_t

Enumeration Type Documentation

◆ ck_gemm_schedule_t

Function Documentation

◆ ck_gemm_dynamic_schedule_enabled()

◆ ck_get_gemm_schedule()

◆ ck_set_gemm_schedule()

◆ ck_threadpool_barrier()

◆ ck_threadpool_bounded_capacity()

◆ ck_threadpool_capacity()

◆ ck_threadpool_create()

◆ ck_threadpool_create_capacity()

◆ ck_threadpool_destroy()

◆ ck_threadpool_dispatch()

◆ ck_threadpool_dispatch_n()

◆ ck_threadpool_global()

◆ ck_threadpool_global_destroy()

◆ ck_threadpool_n_threads()

◆ ck_threadpool_parallel_for_n()

◆ ck_threadpool_pause()

◆ ck_threadpool_profile_reset()

◆ ck_threadpool_profile_snapshot()

◆ ck_threadpool_resume()

◆ ck_threadpool_thread_id()