#include "ckernel_engine.h"
#include "ck_threadpool.h"
#include <dlfcn.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>

Macros
#define	CK_ADD_PAIR(pid, cid)

Typedefs
typedef size_t(*	ck_strict_mtmd_clip_embd_nbytes_by_img_fn) (void *, int, int)

typedef int(*	ck_strict_mtmd_clip_encode_float_image_fn) (void , int, float , int, int, float *)

typedef void(*	ck_strict_mtmd_clip_free_fn) (void *)

typedef void (	ck_strict_mtmd_clip_init_fn) (const char *, int, int, int, int, int)

Functions
int	ck_get_num_threads (void)

int	ck_get_physical_cores (void)

ck_threadpool_t *	ck_get_threadpool (void)

static int	ck_parse_env_int (const char *name)

void	ck_set_num_threads (int num_threads)

void	ck_set_strict_parity (int enabled)

const float *	ck_strict_consume_next_gemm_a (size_t elems)

int	ck_strict_mtmd_clip_encode_planar_f32 (const float planar, int channels, int height, int width, float out, size_t out_elems)

int	ck_strict_parity_enabled (void)

void	ck_strict_store_next_gemm_a (const float *data, size_t elems)

void	ck_threadpool_init (void)

void	ck_threadpool_shutdown (void)

Variables
static float *	ck_strict_next_gemm_a = NULL

static size_t	ck_strict_next_gemm_a_cap = 0

static size_t	ck_strict_next_gemm_a_size = 0

static int	ck_strict_next_gemm_a_valid = 0

static int	ck_strict_parity = 0

static int	g_num_threads = 0

static int	g_threads_initialized = 0

Macro Definition Documentation

◆ CK_ADD_PAIR

#define CK_ADD_PAIR	(	pid,
		cid
	)

Value:

            do {                                                                 \
                if ((pid) >= 0 && (cid) >= 0) {                                  \
                    int exists = 0;                                              \
                    for (int ii = 0; ii < seen_count; ++ii) {                    \
                        if (seen[ii].physical_id == (pid) &&                     \
                            seen[ii].core_id == (cid)) {                         \
                            exists = 1;                                          \
                            break;                                               \
                        }                                                        \
                    }                                                            \
                    if (!exists && seen_count < seen_cap) {                      \
                        seen[seen_count].physical_id = (pid);                    \
                        seen[seen_count].core_id = (cid);                        \
                        ++seen_count;                                            \
                    }                                                            \
                }                                                                \
            } while (0)

Typedef Documentation

◆ ck_strict_mtmd_clip_embd_nbytes_by_img_fn

typedef size_t(* ck_strict_mtmd_clip_embd_nbytes_by_img_fn) (void *, int, int)

Definition at line 81 of file ckernel_strict.c.

◆ ck_strict_mtmd_clip_encode_float_image_fn

typedef int(* ck_strict_mtmd_clip_encode_float_image_fn) (void *, int, float *, int, int, float *)

Definition at line 82 of file ckernel_strict.c.

◆ ck_strict_mtmd_clip_free_fn

typedef void(* ck_strict_mtmd_clip_free_fn) (void *)

Definition at line 80 of file ckernel_strict.c.

◆ ck_strict_mtmd_clip_init_fn

typedef void *(* ck_strict_mtmd_clip_init_fn) (const char *, int, int, int, int, int)

Definition at line 79 of file ckernel_strict.c.

Function Documentation

◆ ck_get_num_threads()

int ck_get_num_threads ( void )

Definition at line 310 of file ckernel_strict.c.

{
    // Auto-initialize if not set
    if (!g_threads_initialized) {
        ck_set_num_threads(0);  // Auto-detect
    }
    return g_num_threads;
}

References ck_set_num_threads(), g_num_threads, and g_threads_initialized.

Referenced by attention_forward_decode_head_major_gqa_flash_f16cache_contract(), gemm_blocked_serial(), and global_pool_init().

◆ ck_get_physical_cores()

int ck_get_physical_cores ( void )

Definition at line 170 of file ckernel_strict.c.

{
    int physical_cores = 0;
    int logical_cores = (int)sysconf(_SC_NPROCESSORS_ONLN);
    if (logical_cores <= 0) {
        logical_cores = 1;
    }
 
    int cpu_cores_hint = 0;
    int siblings_hint = 0;
 
    // Read from /proc/cpuinfo (Linux) and count unique (physical id, core id) pairs.
    FILE *f = fopen("/proc/cpuinfo", "r");
    if (f) {
        char line[256];
        int physical_id = -1;
        int core_id = -1;
 
        struct {
            int physical_id;
            int core_id;
        } seen[8192];
        int seen_count = 0;
 
        const int seen_cap = (int)(sizeof(seen) / sizeof(seen[0]));
 
        // Helper: add (pid,cid) to set if not present.
        #define CK_ADD_PAIR(pid, cid)                                            \
            do {                                                                 \
                if ((pid) >= 0 && (cid) >= 0) {                                  \
                    int exists = 0;                                              \
                    for (int ii = 0; ii < seen_count; ++ii) {                    \
                        if (seen[ii].physical_id == (pid) &&                     \
                            seen[ii].core_id == (cid)) {                         \
                            exists = 1;                                          \
                            break;                                               \
                        }                                                        \
                    }                                                            \
                    if (!exists && seen_count < seen_cap) {                      \
                        seen[seen_count].physical_id = (pid);                    \
                        seen[seen_count].core_id = (cid);                        \
                        ++seen_count;                                            \
                    }                                                            \
                }                                                                \
            } while (0)
 
        while (fgets(line, sizeof(line), f)) {
            int val;
 
            // Blank line separates processor blocks.
            if (line[0] == '\n' || line[0] == '\0') {
                CK_ADD_PAIR(physical_id, core_id);
                physical_id = -1;
                core_id = -1;
                continue;
            }
 
            if (sscanf(line, "physical id : %d", &val) == 1) {
                physical_id = val;
                continue;
            }
            if (sscanf(line, "core id : %d", &val) == 1) {
                core_id = val;
                continue;
            }
            if (sscanf(line, "cpu cores : %d", &val) == 1) {
                if (val > cpu_cores_hint) cpu_cores_hint = val;
                continue;
            }
            if (sscanf(line, "siblings : %d", &val) == 1) {
                if (val > siblings_hint) siblings_hint = val;
                continue;
            }
        }
        fclose(f);
 
        // Handle file without trailing blank line.
        CK_ADD_PAIR(physical_id, core_id);
 
        #undef CK_ADD_PAIR
 
        physical_cores = seen_count;
    }
 
    // Fallback: infer threads-per-core from siblings/cpu cores when pair data
    // is missing (common in containers/VMs).
    if (physical_cores <= 1 && logical_cores > 1) {
        int threads_per_core = 0;
        if (siblings_hint > 0 && cpu_cores_hint > 0 && siblings_hint >= cpu_cores_hint) {
            threads_per_core = siblings_hint / cpu_cores_hint;
        }
        if (threads_per_core > 1) {
            int inferred_physical = logical_cores / threads_per_core;
            if (inferred_physical > 1) {
                return inferred_physical;
            }
        }
        if (cpu_cores_hint > 1 && cpu_cores_hint <= logical_cores) {
            return cpu_cores_hint;
        }
        return logical_cores;
    }
 
    if (physical_cores > 1) {
        return physical_cores;
    }
 
    return logical_cores;
}

References CK_ADD_PAIR.

Referenced by ck_set_num_threads(), ck_threadpool_create_capacity(), and global_pool_init().

◆ ck_get_threadpool()

ck_threadpool_t * ck_get_threadpool ( void )

Get the global thread pool handle for dispatch. Convenience wrapper — initializes on first call.

Definition at line 350 of file ckernel_strict.c.

{
    return ck_threadpool_global();
}

References ck_threadpool_global().

◆ ck_parse_env_int()

static int ck_parse_env_int ( const char * name )

static

Definition at line 153 of file ckernel_strict.c.

{
    const char *val = getenv(name);
    if (!val || !val[0]) {
        return 0;
    }
 
    errno = 0;
    char *end = NULL;
    long n = strtol(val, &end, 10);
    if (errno != 0 || end == val || n <= 0 || n > (1L << 20)) {
        return 0;
    }
    return (int)n;
}

References end.

Referenced by ck_set_num_threads().

◆ ck_set_num_threads()

void ck_set_num_threads ( int num_threads )

Definition at line 280 of file ckernel_strict.c.

{
    // 0 = auto-detect
    if (num_threads <= 0) {
        // Prefer explicit env controls when present:
        // - CK_NUM_THREADS: engine-level override
        // - OMP_NUM_THREADS: standard OpenMP control (set by `ck run --threads`)
        int env_threads = ck_parse_env_int("CK_NUM_THREADS");
        if (env_threads <= 0) {
            env_threads = ck_parse_env_int("OMP_NUM_THREADS");
        }
        num_threads = env_threads > 0 ? env_threads : ck_get_physical_cores();
    }
 
    g_num_threads = num_threads;
    g_threads_initialized = 1;
 
#ifdef _OPENMP
    omp_set_dynamic(0);  // Disable dynamic adjustment
    omp_set_num_threads(num_threads);
#endif
 
#if defined(USE_MKL)
    mkl_set_num_threads(num_threads);
#endif
 
    fprintf(stderr, "[CK] Set %d threads (auto=%d)\n",
            num_threads, ck_get_physical_cores());
}

References ck_get_physical_cores(), ck_parse_env_int(), g_num_threads, and g_threads_initialized.

Referenced by ck_get_num_threads().

◆ ck_set_strict_parity()

void ck_set_strict_parity ( int enabled )

Definition at line 28 of file ckernel_strict.c.

{
    ck_strict_parity = enabled ? 1 : 0;
    if (!ck_strict_parity) {
        ck_strict_next_gemm_a_valid = 0;
        ck_strict_next_gemm_a_size = 0;
    }
#ifdef _OPENMP
    if (ck_strict_parity) {
        omp_set_dynamic(0);
        omp_set_num_threads(1);
    }
#endif
}

References ck_strict_next_gemm_a_size, ck_strict_next_gemm_a_valid, and ck_strict_parity.

◆ ck_strict_consume_next_gemm_a()

const float * ck_strict_consume_next_gemm_a ( size_t elems )

Definition at line 70 of file ckernel_strict.c.

{
    if (!ck_strict_parity || !ck_strict_next_gemm_a_valid || ck_strict_next_gemm_a_size != elems) {
        return NULL;
    }
    ck_strict_next_gemm_a_valid = 0;
    return ck_strict_next_gemm_a;
}

References ck_strict_next_gemm_a, ck_strict_next_gemm_a_size, ck_strict_next_gemm_a_valid, and ck_strict_parity.

Referenced by gemm_nt_q8_0_q8_0_contract().

◆ ck_strict_mtmd_clip_encode_planar_f32()

int ck_strict_mtmd_clip_encode_planar_f32	(	const float *	planar,
		int	channels,
		int	height,
		int	width,
		float *	out,
		size_t	out_elems
	)

Definition at line 84 of file ckernel_strict.c.

{
    const char *gguf_path = getenv("CK_STRICT_GGUF_PATH");
    const char *shim_path = getenv("CK_STRICT_MTMD_SHIM_SO");
    if (!gguf_path || !gguf_path[0] || !shim_path || !shim_path[0]) {
        return 0;
    }
    if (!planar || !out || channels != 3 || height <= 0 || width <= 0) {
        return 0;
    }
 
    void *shim = dlopen(shim_path, RTLD_LAZY | RTLD_LOCAL);
    if (!shim) {
        return 0;
    }
 
    ck_strict_mtmd_clip_init_fn init_fn =
        (ck_strict_mtmd_clip_init_fn) dlsym(shim, "ck_mtmd_clip_init");
    ck_strict_mtmd_clip_free_fn free_fn =
        (ck_strict_mtmd_clip_free_fn) dlsym(shim, "ck_mtmd_clip_free");
    ck_strict_mtmd_clip_embd_nbytes_by_img_fn embd_nbytes_fn =
        (ck_strict_mtmd_clip_embd_nbytes_by_img_fn) dlsym(shim, "ck_mtmd_clip_embd_nbytes_by_img");
    ck_strict_mtmd_clip_encode_float_image_fn encode_fn =
        (ck_strict_mtmd_clip_encode_float_image_fn) dlsym(shim, "ck_mtmd_clip_encode_float_image");
 
    if (!init_fn || !free_fn || !embd_nbytes_fn || !encode_fn) {
        dlclose(shim);
        return 0;
    }
 
    const size_t pixel_count = (size_t) height * (size_t) width;
    float *interleaved = (float *) malloc(pixel_count * (size_t) channels * sizeof(float));
    if (!interleaved) {
        dlclose(shim);
        return 0;
    }
    for (size_t idx = 0; idx < pixel_count; ++idx) {
        interleaved[idx * 3 + 0] = planar[idx];
        interleaved[idx * 3 + 1] = planar[pixel_count + idx];
        interleaved[idx * 3 + 2] = planar[2 * pixel_count + idx];
    }
 
    int ok = 0;
    void *handle = init_fn(gguf_path, 0, 0, 0, 0, 0);
    if (handle) {
        const size_t needed_bytes = embd_nbytes_fn(handle, width, height);
        if (needed_bytes > 0 && needed_bytes <= out_elems * sizeof(float)) {
            ok = encode_fn(handle, 1, interleaved, height, width, out) ? 1 : 0;
        }
        free_fn(handle);
    }
 
    free(interleaved);
    dlclose(shim);
    return ok;
}

◆ ck_strict_parity_enabled()

int ck_strict_parity_enabled ( void )

Definition at line 43 of file ckernel_strict.c.

{
    return ck_strict_parity;
}

References ck_strict_parity.

Referenced by adamw_update_f32_impl(), attention_forward_decode_head_major_gqa_regular(), attention_forward_full_head_major_gqa_exact_strided(), attention_forward_full_head_major_gqa_ggml_strided_workspace(), attention_forward_head_major_gqa_flash_impl(), attention_forward_mixed_visual_chunk_head_major_gqa_flash_strided_gemma4_impl(), ck_dot_q6_k_q8_k_fast_or_ref(), ck_layer_forward_rmsnorm_swiglu(), ck_layer_forward_rmsnorm_swiglu_ref(), ck_mlp_swiglu_forward(), ck_mlp_swiglu_forward_ref(), ck_q6_k_q8_k_provider_name(), ck_q8k_activations_enabled(), gated_deltanet_autoregressive_forward(), gated_deltanet_impl_name(), geglu_forward_fp32(), gemm_avx512_parallel(), gemm_blocked_serial(), gemm_fine_grained_parallel(), gemm_naive_parallel(), gemm_nn_avx512(), gemm_nn_avx512_probe(), gemm_nn_blocked(), gemm_nn_parallel(), gemm_nt_f16(), gemm_nt_fp32_exact_parallel_dispatch(), gemm_nt_q6_k_q8_k_m4_tile(), gemm_nt_q8_0_q8_0_contract(), gemm_tn_avx512(), gemm_tn_blocked(), gemm_tn_parallel(), gemv_q4_k_q8_k_vnni(), gemv_q6_k_q8_k(), gemv_q6_k_q8_k_parallel_simd(), gemv_q8_0_q8_0_contract(), layernorm_forward_rolled_slice(), layernorm_forward_unrolled_slice(), mrope_qk_imrope_positions(), mrope_qk_vision(), rmsnorm_backward(), rmsnorm_forward_strided_f32(), softmax_cross_entropy_loss_index_mean_impl(), softmax_cross_entropy_loss_legacy_mean_impl(), swiglu_backward(), swiglu_forward(), and swiglu_forward_q8_k().

◆ ck_strict_store_next_gemm_a()

void ck_strict_store_next_gemm_a	(	const float *	data,
		size_t	elems
	)

Definition at line 48 of file ckernel_strict.c.

{
    if (!ck_strict_parity || !data || elems == 0) {
        ck_strict_next_gemm_a_valid = 0;
        ck_strict_next_gemm_a_size = 0;
        return;
    }
    if (elems > ck_strict_next_gemm_a_cap) {
        float *next = (float *) realloc(ck_strict_next_gemm_a, elems * sizeof(float));
        if (!next) {
            ck_strict_next_gemm_a_valid = 0;
            ck_strict_next_gemm_a_size = 0;
            return;
        }
        ck_strict_next_gemm_a = next;
        ck_strict_next_gemm_a_cap = elems;
    }
    memcpy(ck_strict_next_gemm_a, data, elems * sizeof(float));
    ck_strict_next_gemm_a_size = elems;
    ck_strict_next_gemm_a_valid = 1;
}

References ck_strict_next_gemm_a, ck_strict_next_gemm_a_cap, ck_strict_next_gemm_a_size, ck_strict_next_gemm_a_valid, and ck_strict_parity.

Referenced by ck_attention_full_ggml_graph_oracle_multihead().

◆ ck_threadpool_init()

void ck_threadpool_init ( void )

Initialize the global thread pool. Called once during engine startup (e.g., from ck_model_init). Uses ck_get_num_threads() for thread count (respects CK_NUM_THREADS env).

Safe to call multiple times — subsequent calls are no-ops.

Definition at line 330 of file ckernel_strict.c.

{
    /* ck_threadpool_global() uses pthread_once internally */
    ck_threadpool_t *pool = ck_threadpool_global();
    (void)pool;
}

References ck_threadpool_global().

◆ ck_threadpool_shutdown()

void ck_threadpool_shutdown ( void )

Shut down the global thread pool. Called during engine teardown. Workers are joined and freed.

Definition at line 341 of file ckernel_strict.c.

{
    ck_threadpool_global_destroy();
}

References ck_threadpool_global_destroy().

Variable Documentation

◆ ck_strict_next_gemm_a

float* ck_strict_next_gemm_a = NULL

static

Definition at line 23 of file ckernel_strict.c.

Referenced by ck_strict_consume_next_gemm_a(), and ck_strict_store_next_gemm_a().

◆ ck_strict_next_gemm_a_cap

size_t ck_strict_next_gemm_a_cap = 0

static

Definition at line 25 of file ckernel_strict.c.

Referenced by ck_strict_store_next_gemm_a().

◆ ck_strict_next_gemm_a_size

size_t ck_strict_next_gemm_a_size = 0

static

Definition at line 24 of file ckernel_strict.c.

Referenced by ck_set_strict_parity(), ck_strict_consume_next_gemm_a(), and ck_strict_store_next_gemm_a().

◆ ck_strict_next_gemm_a_valid

int ck_strict_next_gemm_a_valid = 0

static

Definition at line 26 of file ckernel_strict.c.

Referenced by ck_set_strict_parity(), ck_strict_consume_next_gemm_a(), and ck_strict_store_next_gemm_a().

◆ ck_strict_parity

int ck_strict_parity = 0

static

Definition at line 22 of file ckernel_strict.c.

Referenced by ck_set_strict_parity(), ck_strict_consume_next_gemm_a(), ck_strict_parity_enabled(), and ck_strict_store_next_gemm_a().

◆ g_num_threads

int g_num_threads = 0

static

Definition at line 150 of file ckernel_strict.c.

Referenced by ck_get_num_threads(), and ck_set_num_threads().

◆ g_threads_initialized

int g_threads_initialized = 0

static

Definition at line 151 of file ckernel_strict.c.

Referenced by ck_get_num_threads(), and ck_set_num_threads().

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ CK_ADD_PAIR

Typedef Documentation

◆ ck_strict_mtmd_clip_embd_nbytes_by_img_fn

◆ ck_strict_mtmd_clip_encode_float_image_fn

◆ ck_strict_mtmd_clip_free_fn

◆ ck_strict_mtmd_clip_init_fn

Function Documentation

◆ ck_get_num_threads()

◆ ck_get_physical_cores()

◆ ck_get_threadpool()

◆ ck_parse_env_int()

◆ ck_set_num_threads()

◆ ck_set_strict_parity()

◆ ck_strict_consume_next_gemm_a()

◆ ck_strict_mtmd_clip_encode_planar_f32()

◆ ck_strict_parity_enabled()

◆ ck_strict_store_next_gemm_a()

◆ ck_threadpool_init()

◆ ck_threadpool_shutdown()

Variable Documentation

◆ ck_strict_next_gemm_a

◆ ck_strict_next_gemm_a_cap

◆ ck_strict_next_gemm_a_size

◆ ck_strict_next_gemm_a_valid

◆ ck_strict_parity

◆ g_num_threads

◆ g_threads_initialized