hakmem/core/hakmem_tiny_init.inc

// hakmem_tiny_init.inc
// Note: uses TLS ops inline helpers for prewarm when class5 hotpath is enabled
#include "hakmem_tiny_tls_ops.h"
#include "box/prewarm_box.h"  // Box Prewarm API (Priority 3)
// Phase 2D-2: Initialization function extraction
//
// This file contains the hak_tiny_init() function extracted from hakmem_tiny.c
// to improve code organization. Reduces main file by 450 lines (24%).
//
// Cold path only - called once at startup.

void hak_tiny_init(void) {
    if (g_tiny_initialized) return;

    // Step 1: Simple initialization (static global is already zero-initialized)
    g_tiny_initialized = 1;


    // Reset fast-cache defaults and apply preset (if provided)
    tiny_config_reset_defaults();
    char* preset_env = getenv("HAKMEM_TINY_PRESET");
    if (preset_env) {
        if (strcasecmp(preset_env, "TIGHT") == 0) {
            TINY_PRESET_TIGHT();
        } else if (strcasecmp(preset_env, "ULTRA_TIGHT") == 0 ||
                   strcasecmp(preset_env, "ULTRATIGHT") == 0) {
            TINY_PRESET_ULTRA_TIGHT();
        } else {
            TINY_PRESET_BALANCED();
        }
    }

    // Phase 6.14: Read environment variable for Registry ON/OFF
    char* env = getenv("HAKMEM_USE_REGISTRY");
    if (env) {
        g_use_registry = atoi(env);
    } else {
        g_use_registry = 1;  // Default ON for multi-thread safety
    }

    // Phase 6.15: Runtime toggle to allow Tiny within wrappers
    // HAKMEM_WRAP_TINY=1 → enable Tiny fast-path during wrapper calls
    char* wrap_env = getenv("HAKMEM_WRAP_TINY");
    if (wrap_env && atoi(wrap_env) != 0) {
        g_wrap_tiny_enabled = 1;
    }
    char* wrap_refill_env = getenv("HAKMEM_WRAP_TINY_REFILL");
    if (wrap_refill_env && atoi(wrap_refill_env) != 0) {
        g_wrap_tiny_refill = 1;
    }
    // Remote-drain knobs
    char* rth = getenv("HAKMEM_TINY_REMOTE_DRAIN_THRESHOLD");
    if (rth) { int v = atoi(rth); if (v > 0) g_remote_drain_thresh = v; }
    char* rr = getenv("HAKMEM_TINY_REMOTE_DRAIN_TRYRATE");
    if (rr) { int v = atoi(rr); if (v > 0) g_remote_drain_tryrate = v; }
    char* cs = getenv("HAKMEM_TINY_COUNT_SAMPLE");
    if (cs) { int v = atoi(cs); if (v>=0 && v<=16) g_tiny_count_sample_exp = v; }

    int mem_diet_enabled = 1;  // Default: Enable for memory efficiency
    char* memdiet_env = getenv("HAKMEM_TINY_MEM_DIET");
    if (memdiet_env && atoi(memdiet_env) == 0) {
        mem_diet_enabled = 0;  // Allow disabling via env
    }
    if (mem_diet_enabled) {
        if (g_mag_cap_limit > 64) g_mag_cap_limit = 64;
    }

    // Optional: Magazine cap limit (runtime lower bound)
    char* mag_env = getenv("HAKMEM_TINY_MAG_CAP");
    if (mag_env) {
        int val = atoi(mag_env);
        if (val > 0 && val < g_mag_cap_limit) g_mag_cap_limit = val;
    }

    // Phase X: Initialize TLS free-list defaults
    for (int i = 0; i < TINY_NUM_CLASSES; i++) {
        TinyTLSList* tls = &g_tls_lists[i];
        tls->head = NULL;
        tls->count = 0;
        uint32_t base_cap = (uint32_t)tiny_default_cap(i);
        uint32_t class_max = (uint32_t)tiny_cap_max_for_class(i);
        if (base_cap > class_max) base_cap = class_max;
        if ((uint32_t)g_mag_cap_limit < base_cap) base_cap = (uint32_t)g_mag_cap_limit;
        if (g_mag_cap_override[i] > 0) {
            uint32_t ov = (uint32_t)g_mag_cap_override[i];
            if (ov > class_max) ov = class_max;
            if (ov > (uint32_t)g_mag_cap_limit) ov = (uint32_t)g_mag_cap_limit;
            if (ov != 0u) base_cap = ov;
        }
        if (base_cap == 0u) base_cap = 32u;
        tls->cap = base_cap;
        tls->refill_low = tiny_tls_default_refill(base_cap);
        tls->spill_high = tiny_tls_default_spill(base_cap);
        tiny_tls_publish_targets(i, base_cap);
    }
    if (mem_diet_enabled) {
        tiny_apply_mem_diet();
    }

    // Enable signal-triggered stats dump if requested (SIGUSR1)
    hak_tiny_enable_signal_dump();

    // Phase 6.23: SuperSlab support (mimalloc-style fast allocation)
    // Allow runtime disable/enable via env (0=off, 1=on)
    // Phase 6-2.5 FIX: SuperSlab is independent from diet mode (both are performance-critical)
    // - SuperSlab: Fast allocation/free (defaults to 1, set in hakmem_config.c:334)
    // - Diet mode: Magazine capacity limits only (doesn't disable subsystems)
    char* superslab_env = getenv("HAKMEM_TINY_USE_SUPERSLAB");
    if (superslab_env) {
        g_use_superslab = (atoi(superslab_env) != 0) ? 1 : 0;
    }

    // Initialize Super Front Cache (SFC) with bench-friendly defaults
    // Enabled by default; can be disabled via HAKMEM_SFC_ENABLE=0
    {
        extern void sfc_init(void);
        sfc_init();
    }
    // Note: Diet mode no longer overrides g_use_superslab (removed lines 104-105)
    // SuperSlab defaults to 1 unless explicitly disabled via env var
    // One-shot hint: publish/adopt requires SuperSlab ON
    {
        static int hint_once = 0;
        if (!hint_once) {
            const char* must_adopt = getenv("HAKMEM_TINY_MUST_ADOPT");
            if ((!superslab_env || g_use_superslab == 0) && must_adopt && atoi(must_adopt) != 0) {
                fprintf(stderr, "[HINT] HAKMEM_TINY_USE_SUPERSLAB=0: publish/adopt pipeline is disabled. Set =1 for mailbox/adopt.\n");
            }
            hint_once = 1;
        }
    }
    {
        char* tlslist_env = getenv("HAKMEM_TINY_TLS_LIST");
        if (tlslist_env) {
            g_tls_list_enable = (atoi(tlslist_env) != 0) ? 1 : 0;
        }
    }
    // Phase 9.4: TLS SLL toggle (default ON) + class mask
    {
        char* sll_env = getenv("HAKMEM_TINY_TLS_SLL");
        if (sll_env && atoi(sll_env) == 0) {
            g_tls_sll_enable = 0;
        }
        // Restrict SLL usage to selected classes
        extern int g_tls_sll_class_mask;
        g_tls_sll_class_mask = 0xFF;  // default all classes (0..7)
        char* c03 = getenv("HAKMEM_TINY_SLL_C03_ONLY");
        if (c03 && atoi(c03) != 0) {
            g_tls_sll_class_mask = 0x0F;  // classes 0..3 only
        }
        char* msk = getenv("HAKMEM_TINY_SLL_MASK");
        if (msk && *msk) {
            int v = (int)strtol(msk, NULL, 0);
            if (v >= 0 && v <= 0xFF) g_tls_sll_class_mask = v;
        }
    }
    // Path debug enabled?
    {
        char* pd = getenv("HAKMEM_TINY_PATH_DEBUG");
        g_path_debug_enabled = (pd && atoi(pd) != 0) ? 1 : 0;
    }
    // Ultra-Bump TLS shadow（既定ON、envでOFF可能）
    {
        char* ub = getenv("HAKMEM_TINY_BUMP_SHADOW");
        if (ub) { g_ultra_bump_shadow = (atoi(ub) != 0) ? 1 : 0; }
        char* bc = getenv("HAKMEM_TINY_BUMP_CHUNK");
        if (bc) { int v = atoi(bc); if (v > 0 && v < 32768) g_bump_chunk = v; }
    }
    // Refill-one-on-miss（チェーン生成を避け、1個だけ確保して返す）
    {
        char* ro = getenv("HAKMEM_TINY_REFILL_ONE_ON_MISS");
        if (ro) g_refill_one_on_miss = (atoi(ro) != 0) ? 1 : 0;
    }
    // SLL multiplier (hot tiny classes)
    char* sllmul = getenv("HAKMEM_SLL_MULTIPLIER");
    if (sllmul) {
        int v = atoi(sllmul);
        if (v < 1) {
            v = 1;
        } else if (v > 16) {
            v = 16;  // guardrail
        }
        g_sll_multiplier = v;
    }

    // Ultra-Simple front - REMOVED (dead code cleanup 2025-11-27)

    // Background Bin/Spill/Remote: runtime ENV toggles removed (fixed OFF)
    // Initialize heads to keep structures consistent.
    for (int k = 0; k < TINY_NUM_CLASSES; k++) {
        atomic_store_explicit(&g_bg_bin_head[k], (uintptr_t)0, memory_order_relaxed);
        atomic_store_explicit(&g_remote_target_head[k], (uintptr_t)0, memory_order_relaxed);
        atomic_store_explicit(&g_remote_target_len[k], 0u, memory_order_relaxed);
    }
    // Optional prefetch enable
    {
        char* pf = getenv("HAKMEM_TINY_PREFETCH");
        if (pf && atoi(pf) != 0) g_tiny_prefetch = 1;
    }
    // Refill batch tuning
    char* rmax = getenv("HAKMEM_TINY_REFILL_MAX");
    if (rmax) { int v = atoi(rmax); if (v > 0) g_tiny_refill_max = v; }
    char* rmaxh = getenv("HAKMEM_TINY_REFILL_MAX_HOT");
    if (rmaxh) { int v = atoi(rmaxh); if (v > 0) g_tiny_refill_max_hot = v; }
    // Per-class overrides: HAKMEM_TINY_REFILL_MAX_C{0..7}, HAKMEM_TINY_REFILL_MAX_HOT_C{0..7}
    for (int k = 0; k < TINY_NUM_CLASSES; k++) {
        char key1[64]; snprintf(key1, sizeof(key1), "HAKMEM_TINY_REFILL_MAX_C%d", k);
        char* v1 = getenv(key1); if (v1) { int vv = atoi(v1); if (vv > 0) g_refill_max_c[k] = vv; }
        char key2[64]; snprintf(key2, sizeof(key2), "HAKMEM_TINY_REFILL_MAX_HOT_C%d", k);
        char* v2 = getenv(key2); if (v2) { int vv = atoi(v2); if (vv > 0) g_refill_max_hot_c[k] = vv; }
    }
    // Stats sampling rate (compile-time gated) via env HAKMEM_TINY_STAT_RATE_LG
#if defined(HAKMEM_ENABLE_STATS) && defined(HAKMEM_TINY_STAT_SAMPLING)
    {
        char* sr = getenv("HAKMEM_TINY_STAT_RATE_LG");
        if (sr) { int lg = atoi(sr); if (lg >= 0 && lg <= 31) g_stat_rate_lg = lg; }
        // 関数ポインタ選択（分岐をホットパスから排除）
        g_stat_alloc_fn = (g_stat_rate_lg == 0) ? hkm_stat_alloc_always : hkm_stat_alloc_sampled;
    }
#elif defined(HAKMEM_ENABLE_STATS)
    // サンプリング未使用時は毎回更新
    // FIXME: g_stat_alloc_fn and hkm_stat_alloc_always not yet implemented
    // Stats are recorded via hkm_stat_alloc() in HAK_RET_ALLOC macro instead
    // g_stat_alloc_fn = hkm_stat_alloc_always;
#endif

    // Spill hysteresis（freeホットパスでgetenvしない）
    {
        char* sh = getenv("HAKMEM_TINY_SPILL_HYST");
        if (sh) { int v = atoi(sh); if (v < 0) v = 0; g_spill_hyst = v; }
    }
    char* ultra_env = getenv("HAKMEM_TINY_ULTRA");
    if (ultra_env && atoi(ultra_env) != 0) {
        g_tiny_ultra = 1;
    }
    char* uval = getenv("HAKMEM_TINY_ULTRA_VALIDATE");
    if (uval && atoi(uval) != 0) {
        g_ultra_validate = 1;
    }

    // Ultra env overrides: per-class batch and sll_cap
    // HAKMEM_TINY_ULTRA_BATCH_C{0..7}, HAKMEM_TINY_ULTRA_SLL_CAP_C{0..7}
    char var[64];
    for (int i = 0; i < TINY_NUM_CLASSES; i++) {
        snprintf(var, sizeof(var), "HAKMEM_TINY_ULTRA_BATCH_C%d", i);
        char* vb = getenv(var);
        if (vb) { int v = atoi(vb); if (v > 0) g_ultra_batch_override[i] = v; }
        snprintf(var, sizeof(var), "HAKMEM_TINY_ULTRA_SLL_CAP_C%d", i);
        char* vc = getenv(var);
        if (vc) { int v = atoi(vc); if (v > 0) g_ultra_sll_cap_override[i] = v; }
        // Normal-path per-class overrides
        snprintf(var, sizeof(var), "HAKMEM_TINY_MAG_CAP_C%d", i);
        char* vm = getenv(var);
        if (vm) { int v = atoi(vm); if (v > 0 && v <= TINY_TLS_MAG_CAP) g_mag_cap_override[i] = v; }
        snprintf(var, sizeof(var), "HAKMEM_TINY_SLL_CAP_C%d", i);
        char* vs = getenv(var);
        // Phase12: g_sll_cap_override はレガシー互換ダミー。SLL cap は sll_cap_for_class()/TinyAcePolicy が担当するため、ここでは無視する。

        // Front refill count per-class override (fast path tuning)
        snprintf(var, sizeof(var), "HAKMEM_TINY_REFILL_COUNT_C%d", i);
        char* rc = getenv(var);
        if (rc) { int v = atoi(rc); if (v < 0) v = 0; if (v > 256) v = 256; g_refill_count_class[i] = v; }
    }

    // Front refill count globals
    // Phase 10: Set aggressive defaults for hot and mid classes
    {
        char* g = getenv("HAKMEM_TINY_REFILL_COUNT");
        if (g) { int v = atoi(g); if (v < 0) v = 0; if (v > 256) v = 256; g_refill_count_global = v; }
        else { g_refill_count_global = 64; }  // Phase 10: default 64 (was 16)

        char* h = getenv("HAKMEM_TINY_REFILL_COUNT_HOT");
        if (h) { int v = atoi(h); if (v < 0) v = 0; if (v > 256) v = 256; g_refill_count_hot = v; }
        else { g_refill_count_hot = 128; }  // Phase 10: default 128 for hot classes (C0-C3)

        char* m = getenv("HAKMEM_TINY_REFILL_COUNT_MID");
        if (m) { int v = atoi(m); if (v < 0) v = 0; if (v > 256) v = 256; g_refill_count_mid = v; }
        else { g_refill_count_mid = 96; }  // Phase 10: default 96 for mid classes (C4-C7)
    }
    // Sensible default for class 7 (1024B): favor larger refill to reduce refills/syscalls
    if (g_refill_count_class[7] == 0) {
        g_refill_count_class[7] = 128;  // Phase 10: increased from 64 to 128
    }
    {
        char* fast_env = getenv("HAKMEM_TINY_FAST");
        if (fast_env && atoi(fast_env) == 0) g_fast_enable = 0;
        int fast_global = -1;
        char* fast_cap_env = getenv("HAKMEM_TINY_FAST_CAP");
        if (fast_cap_env) {
            int v = atoi(fast_cap_env);
            if (v >= 0 && v <= TINY_TLS_MAG_CAP) fast_global = v;
        }
        for (int i = 0; i < TINY_NUM_CLASSES; i++) {
            uint16_t cap = g_fast_cap_defaults[i];
            if (fast_global >= 0) cap = (uint16_t)fast_global;
            snprintf(var, sizeof(var), "HAKMEM_TINY_FAST_CAP_C%d", i);
            char* fc = getenv(var);
            if (fc) {
                int v = atoi(fc);
                if (v < 0) v = 0;
                if (v > TINY_TLS_MAG_CAP) v = TINY_TLS_MAG_CAP;
                cap = (uint16_t)v;
                g_fast_cap_locked[i] = 1;
            } else if (fast_global >= 0) {
                g_fast_cap_locked[i] = 1;
            } else {
                g_fast_cap_locked[i] = 0;
            }
            g_fast_cap[i] = cap;
        }
    }

    {
        const char* dbg_fast = getenv("HAKMEM_TINY_DEBUG_FAST0");
        if (dbg_fast && atoi(dbg_fast) != 0) {
            g_debug_fast0 = 1;
            g_fast_enable = 0;
            g_hotmag_enable = 0;
            g_tls_list_enable = 0;
        }
        const char* dbg_remote = getenv("HAKMEM_TINY_DEBUG_REMOTE_GUARD");
        if (dbg_remote && atoi(dbg_remote) != 0) {
            g_debug_remote_guard = 1;
        }
        const char* rf_force = getenv("HAKMEM_TINY_RF_FORCE_NOTIFY");
        if (rf_force && atoi(rf_force) != 0) {
            extern int g_remote_force_notify;
            g_remote_force_notify = 1;
        }
        const char* safe_free = getenv("HAKMEM_SAFE_FREE");
        if (safe_free && atoi(safe_free) != 0) {
            extern int g_tiny_safe_free; g_tiny_safe_free = 1;
        }
        const char* safe_free_strict = getenv("HAKMEM_SAFE_FREE_STRICT");
        if (safe_free_strict && atoi(safe_free_strict) != 0) {
            extern int g_tiny_safe_free_strict; g_tiny_safe_free_strict = 1;
        }
        const char* force_remote = getenv("HAKMEM_TINY_FORCE_REMOTE");
        if (force_remote && atoi(force_remote) != 0) {
            extern int g_tiny_force_remote; g_tiny_force_remote = 1;
        }
        // Remote side-table (debug only)
        tiny_remote_side_init_from_env();
    }
    static int g_super_trace = -1;
    if (__builtin_expect(g_super_trace == -1, 0)) {
        const char* tr = getenv("HAKMEM_TINY_SUPERSLAB_TRACE");
        g_super_trace = (tr && atoi(tr) != 0) ? 1 : 0;
    }
    if (g_super_trace) {
        static int logged_once = 0;
        if (!logged_once) {
            fprintf(stderr, "[SUPERTRACE] mem_diet=%d env=%s g_use_superslab=%d fast_enable=%d cap0=%u cap1=%u cap2=%u cap3=%u cap4=%u reslist=%d\n",
                    mem_diet_enabled,
                    superslab_env ? superslab_env : "(null)",
                    g_use_superslab,
                    g_fast_enable,
                    (unsigned)g_fast_cap[0],
                    (unsigned)g_fast_cap[1],
                    (unsigned)g_fast_cap[2],
                    (unsigned)g_fast_cap[3],
                    (unsigned)g_fast_cap[4],
                    g_tls_list_enable);
            logged_once = 1;
        }
    }
    tiny_ace_init_defaults();
    char* fc_env = getenv("HAKMEM_TINY_FASTCACHE");
    if (fc_env && atoi(fc_env) != 0) {
        g_fastcache_enable = 1;
    }
    char* fe_env = getenv("HAKMEM_TINY_FRONTEND");
    if (fe_env && atoi(fe_env) != 0) {
        g_frontend_enable = 1;
    }
    // TinyQuickSlot opt-in
    {
        char* q = getenv("HAKMEM_TINY_QUICK");
        if (q && atoi(q) != 0) g_quick_enable = 1;
    }

    tiny_obs_start_if_needed();

    // Deferred Intelligence Engine
    char* ie = getenv("HAKMEM_INT_ENGINE");
    if (ie && atoi(ie) != 0) {
        g_int_engine = 1;
        // Initialize frontend fill targets to zero (let engine grow if hot)
        for (int i = 0; i < TINY_NUM_CLASSES; i++) atomic_store(&g_frontend_fill_target[i], 0);
        // Event logging knobs (optional)
        char* its = getenv("HAKMEM_INT_EVENT_TS");
        if (its && atoi(its) != 0) g_int_event_ts = 1;
        char* ism = getenv("HAKMEM_INT_SAMPLE");
        if (ism) { int n = atoi(ism); if (n > 0 && n < 31) g_int_sample_mask = ((1u << n) - 1u); }
        if (pthread_create(&g_int_thread, NULL, intelligence_engine_main, NULL) == 0) {
            g_int_started = 1;
        }
    }

    // Step 2: Initialize Slab Registry (only if enabled)
    if (g_use_registry) {
        memset(g_slab_registry, 0, sizeof(g_slab_registry));
    }

    // Initialize per-class locks
    for (int i = 0; i < TINY_NUM_CLASSES; i++) {
        pthread_mutex_init(&g_tiny_class_locks[i].m, NULL);
    }

    // Phase 8.3: Initialize ACE (Adaptive Cache Engine) state
    for (int i = 0; i < TINY_NUM_CLASSES; i++) {
        g_ss_ace[i].current_lg = 20;  // Start with 1MB SuperSlabs
        g_ss_ace[i].target_lg = 20;   // Default to 1MB
        g_ss_ace[i].hot_score = 0;
        g_ss_ace[i].alloc_count = 0;
        g_ss_ace[i].refill_count = 0;
        g_ss_ace[i].spill_count = 0;
        g_ss_ace[i].live_blocks = 0;
        g_ss_ace[i].last_tick_ns = 0;
    }

    // Lite P1: Pre-allocate Tier 1 (8-64B) hot classes only
    // This avoids initialization overhead for common small allocations
    // Classes 0-3: 8B, 16B, 32B, 64B (256KB total, not 512KB)
    for (int class_idx = 0; class_idx < 4; class_idx++) {
        TinySlab* slab = allocate_new_slab(class_idx);
        if (slab) {
            slab->next = g_tiny_pool.free_slabs[class_idx];
            g_tiny_pool.free_slabs[class_idx] = slab;
        }
    }

    // Phase 11: Initialize SuperSlab Registry and LRU Cache
    if (g_use_superslab) {
        extern void hak_super_registry_init(void);
        extern void hak_ss_lru_init(void);
        extern void hak_ss_prewarm_init(void);

        hak_super_registry_init();
        hak_ss_lru_init();

        // Phase 11: Prewarm SuperSlabs to eliminate mmap/munmap churn
        // ENV: HAKMEM_PREWARM_SUPERSLABS=<count> (e.g., 32, 128)
        hak_ss_prewarm_init();
    }

    if (__builtin_expect(route_enabled_runtime(), 0)) {
        tiny_debug_ring_record(TINY_RING_EVENT_ROUTE, (uint16_t)0xFFFFu, NULL, (uintptr_t)0x494E4954u);
    }
}