hakmem/core/hakmem_tiny_background.inc

// Background Refill Bin (per-class lock-free SLL) — fills in background so the
// front path only does a single CAS pop when both slots/bump are empty.
static int g_bg_bin_enable = 0;                // HAKMEM_TINY_BG_BIN=1
static int g_bg_bin_target = 128;              // HAKMEM_TINY_BG_TARGET (per class)
static _Atomic uintptr_t g_bg_bin_head[TINY_NUM_CLASSES];
static pthread_t g_bg_bin_thread;
static volatile int g_bg_bin_stop = 0;
static int g_bg_bin_started = 0;
// Inline helpers
#include "hakmem_tiny_bg_bin.inc.h"

// ============================================================================
// EXTRACTED TO hakmem_tiny_remote_target.c (Phase 2C-1)
// ============================================================================
// Targeted remote-drain queue moved to separate module
// Functions: remote_target_enqueue(), remote_target_pop()
// Variables: g_bg_remote_enable, g_remote_target_head, g_remote_target_len, g_bg_remote_batch

// ============================================================================
// EXTRACTED TO hakmem_tiny_bg_spill.c/.h (Phase 2C-2)
// ============================================================================
// Background spill/drain queue for SuperSlab freelist returns
// Functions: bg_spill_push_one(), bg_spill_push_chain(), bg_spill_drain_class(), bg_spill_init()
// Variables: g_bg_spill_enable, g_bg_spill_target, g_bg_spill_max_batch, g_bg_spill_head[], g_bg_spill_len[]


static void* tiny_bg_refill_main(void* arg) {
    (void)arg;
    const int sleep_us = 1000; // 1ms
    while (!g_bg_bin_stop) {
        if (!g_bg_bin_enable) { usleep(sleep_us); continue; }
        for (int k = 0; k < TINY_NUM_CLASSES; k++) {
            // まずは小クラスだけ対象（シンプルに）
            if (!is_hot_class(k)) continue;
            int have = bgbin_length_approx(k, g_bg_bin_target);
            if (have >= g_bg_bin_target) continue;
            int need = g_bg_bin_target - have;

            // 生成チェーンを作る（free listやbitmapから、裏で重い処理OK）
            void* chain_head = NULL; void* chain_tail = NULL; int built = 0;
            pthread_mutex_t* lock = &g_tiny_class_locks[k].m;
            pthread_mutex_lock(lock);
            TinySlab* slab = g_tiny_pool.free_slabs[k];
            // Adopt first slab with free blocks; if none, allocate one
            if (!slab) slab = allocate_new_slab(k);
            while (need > 0 && slab) {
                if (slab->free_count == 0) { slab = slab->next; continue; }
                int idx = hak_tiny_find_free_block(slab);
                if (idx < 0) { slab = slab->next; continue; }
                hak_tiny_set_used(slab, idx);
                slab->free_count--;
                size_t bs = g_tiny_class_sizes[k];
                void* p = (char*)slab->base + (idx * bs);
                // prepend to local chain
                tiny_next_write(k, p, chain_head);  // Box API: next pointer write
                chain_head = p;
                if (!chain_tail) chain_tail = p;
                built++; need--;
            }
            pthread_mutex_unlock(lock);

            if (built > 0) {
                bgbin_push_chain(k, chain_head, chain_tail);
            }
        }
        // Drain background spill queues (SuperSlab freelist return)
        // EXTRACTED: Drain logic moved to hakmem_tiny_bg_spill.c (Phase 2C-2)
        if (g_bg_spill_enable) {
            for (int k = 0; k < TINY_NUM_CLASSES; k++) {
                pthread_mutex_t* lock = &g_tiny_class_locks[k].m;
                bg_spill_drain_class(k, lock);
            }
        }
        // Drain remote frees: targeted by per-class queue (avoid scanning all slabs)
        if (g_bg_remote_enable) {
            for (int k = 0; k < TINY_NUM_CLASSES; k++) {
                int processed = 0;
                while (processed < g_bg_remote_batch) {
                    TinySlab* s = remote_target_pop(k);
                    if (!s) break;
                    pthread_mutex_t* lock = &g_tiny_class_locks[k].m;
                    pthread_mutex_lock(lock);
                    tiny_remote_drain_locked(s);
                    pthread_mutex_unlock(lock);
                    processed++;
                    // If more remain (due to concurrent pushes), the slab may be re-enqueued
                    // by producers when threshold is hit again.
                }
            }
        }
        usleep(sleep_us);
    }
    return NULL;
}

static inline void eventq_push(int class_idx, uint32_t size) {
    eventq_push_ex(class_idx, size, HAK_TIER_FRONT, 0, 0, 0);
}

static void* intelligence_engine_main(void* arg) {
    (void)arg;
    const int sleep_us = 100000; // 100ms
    int hist[TINY_NUM_CLASSES] = {0};
    int cnt[TINY_NUM_CLASSES] = {0};
    // Tiny の学習は既定でOFF（実アプリは後段で学習）：
    // HAKMEM_INT_ADAPT_REFILL=1 / HAKMEM_INT_ADAPT_CAPS=1 を明示設定した場合のみON
    int adapt_refill = 0;  // default OFF for Tiny
    int adapt_caps = 0;    // default OFF for Tiny (env can enable)
    char* arf = getenv("HAKMEM_INT_ADAPT_REFILL");
    if (arf) adapt_refill = (atoi(arf) != 0);
    char* acp = getenv("HAKMEM_INT_ADAPT_CAPS");
    if (acp) adapt_caps = (atoi(acp) != 0);
    const int REFILL_MIN = 32, REFILL_MAX = 256;
    const int REFILL_HOT_MIN = 96, REFILL_HOT_MAX = 320;
    // Tiny diet (memory-tight) knobs
    {
        char* rb = getenv("HAKMEM_TINY_RSS_BUDGET_KB");
        if (rb) { int v = atoi(rb); if (v > 0) g_tiny_rss_budget_kb = v; }
        char* st = getenv("HAKMEM_TINY_DIET_STEP");
        if (st) { int v = atoi(st); if (v > 0 && v < 256) g_tiny_diet_step = v; }
        char* tt = getenv("HAKMEM_TINY_INT_TIGHT");
        if (tt) g_tiny_int_tight = (atoi(tt) != 0);
        for (int k = 0; k < TINY_NUM_CLASSES; k++) {
            char var[64]; snprintf(var, sizeof(var), "HAKMEM_TINY_CAP_FLOOR_C%d", k);
            char* vf = getenv(var);
            if (vf) { int v = atoi(vf); if (v > 0 && v < TINY_TLS_MAG_CAP) g_tiny_cap_floor[k] = v; }
        }
    }
    // Idle trim knob
    int idle_trim_ms = 0;
    int idle_flush = 0; // flush magazines on idle tick (optional)
    {
        char* it = getenv("HAKMEM_TINY_IDLE_TRIM_MS");
        if (it) { int v = atoi(it); if (v > 0) idle_trim_ms = v; }
        char* iff = getenv("HAKMEM_TINY_IDLE_FLUSH");
        if (iff) idle_flush = (atoi(iff) != 0);
    }
    int idle_trim_ticks = (idle_trim_ms > 0) ? (idle_trim_ms * 1000 / sleep_us) : 0;
    int idle_tick = 0;

    while (!g_int_stop) {
        // Drain events
        uint32_t h = atomic_load_explicit(&g_ev_head, memory_order_relaxed);
        uint32_t t = atomic_load_explicit(&g_ev_tail, memory_order_acquire);
        while (h != t) {
            AllocEvent ev = g_ev_ring[h & EVENTQ_MASK];
            if (ev.class_idx < TINY_NUM_CLASSES) {
                hist[ev.class_idx]++;
                // TODO: use ev.tier_hit/flags/site_id for richer adaptations
            }
            h++;
        }
        atomic_store_explicit(&g_ev_head, h, memory_order_release);

        // Snapshot counts for this window
        for (int k = 0; k < TINY_NUM_CLASSES; k++) { cnt[k] = hist[k]; }

        // Simple adaptive rule: if class seen a lot, increase fill target; else reduce
        for (int k = 0; k < TINY_NUM_CLASSES; k++) {
            int count = cnt[k];
            hist[k] = 0;  // reset for next window
            int cur = atomic_load_explicit(&g_frontend_fill_target[k], memory_order_relaxed);
            if (count > 1000) {
                int nv = cur + 32; if (nv > 256) nv = 256;  // cap
                atomic_store_explicit(&g_frontend_fill_target[k], nv, memory_order_relaxed);
            } else if (count < 200) {
                int nv = cur - 16; if (nv < 0) nv = 0;
                atomic_store_explicit(&g_frontend_fill_target[k], nv, memory_order_relaxed);
            }
        }
        // Stage 1: adjust refill batch bounds by class grouping (hot tiny vs others)
        if (adapt_refill) {
            int hot_sum = 0, other_sum = 0;
            for (int k = 0; k < TINY_NUM_CLASSES; k++) {
                int cur = atomic_load_explicit(&g_frontend_fill_target[k], memory_order_relaxed);
                if (k <= 3) hot_sum += cur; else other_sum += cur;
            }
            if (hot_sum > 512) {
                int nv = g_tiny_refill_max_hot + 16; if (nv > REFILL_HOT_MAX) nv = REFILL_HOT_MAX; g_tiny_refill_max_hot = nv;
            } else if (hot_sum < 64) {
                int nv = g_tiny_refill_max_hot - 16; if (nv < REFILL_HOT_MIN) nv = REFILL_HOT_MIN; g_tiny_refill_max_hot = nv;
            }
            if (other_sum > 256) {
                int nv = g_tiny_refill_max + 16; if (nv > REFILL_MAX) nv = REFILL_MAX; g_tiny_refill_max = nv;
            } else if (other_sum < 32) {
                int nv = g_tiny_refill_max - 16; if (nv < REFILL_MIN) nv = REFILL_MIN; g_tiny_refill_max = nv;
            }
        }

        // Adapt per-class MAG/SLL caps (light-touch; protects hot classes)
        if (adapt_caps) {
            for (int k = 0; k < TINY_NUM_CLASSES; k++) {
                int hot = (k <= 3);
                // Heuristic thresholds per window
                // Hot classes raise caps more aggressively
                int up_th = hot ? 800 : 1000;
                int dn_th = hot ? 120 : 200;
                if (g_tiny_int_tight) { dn_th = hot ? 200 : 300; }

                // MAG cap override: move toward [min..max] within guard rails
                int mag = g_mag_cap_override[k];
                int mag_min;
                switch (k) {
                    case 0: case 1: case 2: mag_min = 128; break; // 8/16/32B
                    case 3: mag_min = 256; break;                  // 64B (allow larger later)
                    case 4: mag_min = 128; break;                  // 128B
                    default: mag_min = 64; break;
                }
                int mag_max = 512; // soft ceiling; global hard ceiling is TINY_TLS_MAG_CAP
                if (k == 3) mag_max = 1024;
                if (mag <= 0) mag = mag_min; // start from baseline

                if (cnt[k] > up_th) { mag += 16; if (mag > mag_max) mag = mag_max; }
                else if (cnt[k] < dn_th) { mag -= 16; if (mag < mag_min) mag = mag_min; }
                g_mag_cap_override[k] = mag;

                // SLL cap override (hot classes only); keep absolute cap modest
                if (hot) {
                    int sll = g_sll_cap_override[k];
                    if (sll <= 0) sll = 256; // starting point for hot classes
                    int sll_min = 128;
                    if (g_tiny_int_tight && g_tiny_cap_floor[k] > 0) sll_min = g_tiny_cap_floor[k];
                    int sll_max = 1024;
                    if (cnt[k] > up_th) { sll += 32; if (sll > sll_max) sll = sll_max; }
                    else if (cnt[k] < dn_th) { sll -= 32; if (sll < sll_min) sll = sll_min; }
                    g_sll_cap_override[k] = sll;
                }
            }
        }
        // Enforce Tiny RSS budget (if enabled): when over budget, shrink per-class caps by step
        if (g_tiny_rss_budget_kb > 0) {
            int rss = get_rss_kb_self();
            if (rss > g_tiny_rss_budget_kb) {
                for (int k = 0; k < TINY_NUM_CLASSES; k++) {
                    int floor = g_tiny_cap_floor[k]; if (floor <= 0) floor = 64;
                    int mag = g_mag_cap_override[k]; if (mag <= 0) mag = tiny_effective_cap(k);
                    mag -= g_tiny_diet_step; if (mag < floor) mag = floor; g_mag_cap_override[k] = mag;
                    if (k <= 3) {
                        int sll = g_sll_cap_override[k]; if (sll <= 0) sll = mag * 2;
                        int sll_floor = floor; if (sll_floor < 64) sll_floor = 64;
                        sll -= (g_tiny_diet_step * 2); if (sll < sll_floor) sll = sll_floor; g_sll_cap_override[k] = sll;
                    }
                }
            }
        }
        // Optional periodic idle trim (try to keep overhead small)
        if (idle_trim_ticks > 0) {
            idle_tick++;
            if (idle_tick >= idle_trim_ticks) {
                idle_tick = 0;
                // Optional bounded flush of magazines to enable SS empty detection
                if (idle_flush) hak_tiny_magazine_flush_all();
                // Bounded trim: uses per-class locks briefly; acceptable in background
                hak_tiny_trim();
            }
        }
        usleep(sleep_us);
    }
    return NULL;
}