hakmem/core/hakmem_tiny_phase6_wrappers_box.inc

    // Phase 6-1.7: Box Theory Refactoring - Mutual exclusion check
#if HAKMEM_TINY_PHASE6_BOX_REFACTOR
    #if defined(HAKMEM_TINY_PHASE6_METADATA) || defined(HAKMEM_TINY_PHASE6_ULTRA_SIMPLE)
        #error "Cannot enable PHASE6_BOX_REFACTOR with other Phase 6 options"
    #endif

    // Box 1: Atomic Operations (Layer 0 - Foundation)
    #include "tiny_atomic.h"

    // Box 5: Allocation Fast Path (Layer 1 - 3-4 instructions)
    #include "tiny_alloc_fast.inc.h"

    // Box 6: Free Fast Path (Layer 2 - 2-3 instructions)
    #include "tiny_free_fast.inc.h"

    // ---------------- Refill count (Front) global config ----------------
    // Parsed once at init; hot path reads plain ints (no getenv).
    int g_refill_count_global = 0;              // HAKMEM_TINY_REFILL_COUNT
    int g_refill_count_hot = 0;                 // HAKMEM_TINY_REFILL_COUNT_HOT
    int g_refill_count_mid = 0;                 // HAKMEM_TINY_REFILL_COUNT_MID
    int g_refill_count_class[TINY_NUM_CLASSES] = {0}; // HAKMEM_TINY_REFILL_COUNT_C{0..7}

    // Export wrapper functions for hakmem.c to call
    // Phase 6-1.7 Optimization: Remove diagnostic overhead, rely on LTO for inlining
    void* hak_tiny_alloc_fast_wrapper(size_t size) {
        // Phase E5: Ultra fast path (8-instruction alloc, bypasses all layers)
        // Enable with: HAKMEM_ULTRA_FAST_PATH=1 (compile-time)
        #if HAKMEM_ULTRA_FAST_PATH
            void* ret = tiny_alloc_fast_ultra(size);
            if (ret) return ret;
            // Miss → fallback to full fast path
        #endif

        // Bench-only ultra-short path: bypass diagnostics and pointer tracking
        // Enable with: HAKMEM_BENCH_FAST_FRONT=1
        static int g_bench_fast_front = -1;
        if (__builtin_expect(g_bench_fast_front == -1, 0)) {
            const char* e = getenv("HAKMEM_BENCH_FAST_FRONT");
            g_bench_fast_front = (e && *e && *e != '0') ? 1 : 0;
        }
        if (__builtin_expect(g_bench_fast_front, 0)) {
            return tiny_alloc_fast(size);
        }

        static _Atomic uint64_t wrapper_call_count = 0;
        uint64_t call_num = atomic_fetch_add(&wrapper_call_count, 1);

        // Pointer tracking init (first call only)
        PTR_TRACK_INIT();

        // PRIORITY 3: Periodic canary validation (every 1000 ops)
        periodic_canary_check(call_num, "hak_tiny_alloc_fast_wrapper");

        // Box I: Periodic full integrity check (every 5000 ops)
        #if HAKMEM_INTEGRITY_LEVEL >= 3
        if ((call_num % 5000) == 0) {
            extern void integrity_periodic_full_check(const char*);
            integrity_periodic_full_check("periodic check in alloc wrapper");
        }
        #endif

        #if !HAKMEM_BUILD_RELEASE
        if (call_num > 14250 && call_num < 14280 && size <= 1024) {
            fprintf(stderr, "[HAK_TINY_ALLOC_FAST_WRAPPER] call=%lu size=%zu\n", call_num, size);
            fflush(stderr);
        }
        #endif

        void* result = tiny_alloc_fast(size);

        #if !HAKMEM_BUILD_RELEASE
        if (call_num > 14250 && call_num < 14280 && size <= 1024) {
            fprintf(stderr, "[HAK_TINY_ALLOC_FAST_WRAPPER] call=%lu returned %p\n", call_num, result);
            fflush(stderr);
        }
        #endif
        return result;
    }

    void hak_tiny_free_fast_wrapper(void* ptr) {
        // Phase E5: Ultra fast path (6-8 instruction free)
        #if HAKMEM_ULTRA_FAST_PATH
            tiny_free_fast_ultra(ptr);
            return;
        #endif

        static _Atomic uint64_t free_call_count = 0;
        uint64_t call_num = atomic_fetch_add(&free_call_count, 1);
        if (call_num > 14135 && call_num < 14145) {
            fprintf(stderr, "[HAK_TINY_FREE_FAST_WRAPPER] call=%lu ptr=%p\n", call_num, ptr);
            fflush(stderr);
        }
        tiny_free_fast(ptr);
        if (call_num > 14135 && call_num < 14145) {
            fprintf(stderr, "[HAK_TINY_FREE_FAST_WRAPPER] call=%lu completed\n", call_num);
            fflush(stderr);
        }
    }

#elif defined(HAKMEM_TINY_PHASE6_ULTRA_SIMPLE)
    // Phase 6-1.5: Alignment guessing (legacy)

    // Refill count globals (needed for compatibility)
    int g_refill_count_global = 0;
    int g_refill_count_hot = 0;
    int g_refill_count_mid = 0;
    int g_refill_count_class[TINY_NUM_CLASSES] = {0};

    #include "hakmem_tiny_ultra_simple.inc"

    // Wrapper functions for hakmem.c compatibility (not used in ULTRA_SIMPLE but needed for linking)
    void* hak_tiny_alloc_fast_wrapper(size_t size) {
        return hak_tiny_alloc_ultra_simple(size);
    }

    void hak_tiny_free_fast_wrapper(void* ptr) {
        hak_tiny_free_ultra_simple(ptr);
    }
#elif defined(HAKMEM_TINY_PHASE6_METADATA)
    // Phase 6-1.6: Metadata header (recommended)
    #include "hakmem_tiny_metadata.inc"
#endif