hakmem/core/hakmem_tiny_config_box.inc

// hakmem_tiny_config_box.inc
// Box: Tiny allocator configuration, debug counters, and return helpers.
// Extracted from hakmem_tiny.c to reduce file size and isolate config logic.

// ============================================================================
// Global Operation Counter (for debug logging)
// ============================================================================
#include <stdatomic.h>
_Atomic uint64_t g_debug_op_count = 0;

// ============================================================================
// Size class table (Box 3 dependency)
// ============================================================================
// Phase E1-CORRECT: ALL classes have 1-byte header
// These sizes represent TOTAL BLOCK SIZE (stride) = [Header 1B][Data N-1B]
// Usable data = stride - 1 (implicit)
const size_t g_tiny_class_sizes[TINY_NUM_CLASSES] = {
    8,      // Class 0:   8B total = [Header 1B][Data  7B]
    16,     // Class 1:  16B total = [Header 1B][Data 15B]
    32,     // Class 2:  32B total = [Header 1B][Data 31B]
    64,     // Class 3:  64B total = [Header 1B][Data 63B]
    128,    // Class 4: 128B total = [Header 1B][Data 127B]
    256,    // Class 5: 256B total = [Header 1B][Data 255B]
    512,    // Class 6: 512B total = [Header 1B][Data 511B]
    2048    // Class 7: 2048B total = [Header 1B][Data 2047B] (upgraded for 1024B requests)
};

// ============================================================================
// Phase 16: Dynamic Tiny Max Size (ENV: HAKMEM_TINY_MAX_CLASS)
// Phase 17-1: Auto-adjust when Small-Mid enabled
// ============================================================================

// Forward declaration for Small-Mid check
extern bool smallmid_is_enabled(void);

// Optimized: Cached max size for hot path
// Moved to hakmem_tiny.h for global inlining

// ============================================================================
// PRIORITY 1-4: Integrity Check Counters
// ============================================================================
_Atomic uint64_t g_integrity_check_class_bounds = 0;
_Atomic uint64_t g_integrity_check_freelist = 0;
_Atomic uint64_t g_integrity_check_canary = 0;
_Atomic uint64_t g_integrity_check_header = 0;

// Build-time gate for debug counters (path/ultra). Default OFF.
#ifndef HAKMEM_DEBUG_COUNTERS
#define HAKMEM_DEBUG_COUNTERS 0
#endif

int g_debug_fast0 = 0;
int g_debug_remote_guard = 0;
int g_remote_force_notify = 0;
// Tiny free safety (debug)
int g_tiny_safe_free = 0;         // Default OFF for performance; env: HAKMEM_SAFE_FREE=1 でON
int g_tiny_safe_free_strict = 0;  // env: HAKMEM_SAFE_FREE_STRICT=1
int g_tiny_force_remote = 0;      // env: HAKMEM_TINY_FORCE_REMOTE=1

// Build-time gate: Minimal Tiny front (bench-only)

static inline int superslab_trace_enabled(void) {
    static int g_ss_trace_flag = -1;
    if (__builtin_expect(g_ss_trace_flag == -1, 0)) {
        const char* tr = getenv("HAKMEM_TINY_SUPERSLAB_TRACE");
        g_ss_trace_flag = (tr && atoi(tr) != 0) ? 1 : 0;
    }
    return g_ss_trace_flag;
}
// When enabled, physically excludes optional front tiers from the hot path
// (UltraFront/Quick/Frontend/HotMag/SS-try/BumpShadow), leaving:
//   SLL → TLS Magazine → SuperSlab → (remaining slow path)
#ifndef HAKMEM_TINY_MINIMAL_FRONT
#define HAKMEM_TINY_MINIMAL_FRONT 1
#endif
// Strict front: compile-out optional front tiers but keep baseline structure intact
#ifndef HAKMEM_TINY_STRICT_FRONT
#define HAKMEM_TINY_STRICT_FRONT 0
#endif

// Bench-only fast path knobs (defaults)
#ifndef HAKMEM_TINY_BENCH_REFILL
#define HAKMEM_TINY_BENCH_REFILL 8
#endif
// Optional per-class overrides (bench-only)
#ifndef HAKMEM_TINY_BENCH_REFILL8
#define HAKMEM_TINY_BENCH_REFILL8 HAKMEM_TINY_BENCH_REFILL
#endif
#ifndef HAKMEM_TINY_BENCH_REFILL16
#define HAKMEM_TINY_BENCH_REFILL16 HAKMEM_TINY_BENCH_REFILL
#endif
#ifndef HAKMEM_TINY_BENCH_REFILL32
#define HAKMEM_TINY_BENCH_REFILL32 HAKMEM_TINY_BENCH_REFILL
#endif
#ifndef HAKMEM_TINY_BENCH_REFILL64
#define HAKMEM_TINY_BENCH_REFILL64 HAKMEM_TINY_BENCH_REFILL
#endif

// Bench-only warmup amounts (pre-fill TLS SLL on first alloc per class)
#ifndef HAKMEM_TINY_BENCH_WARMUP8
#define HAKMEM_TINY_BENCH_WARMUP8 64
#endif
#ifndef HAKMEM_TINY_BENCH_WARMUP16
#define HAKMEM_TINY_BENCH_WARMUP16 96
#endif
#ifndef HAKMEM_TINY_BENCH_WARMUP32
#define HAKMEM_TINY_BENCH_WARMUP32 160
#endif
#ifndef HAKMEM_TINY_BENCH_WARMUP64
#define HAKMEM_TINY_BENCH_WARMUP64 192
#endif

#ifdef HAKMEM_TINY_BENCH_FASTPATH
static __thread unsigned char g_tls_bench_warm_done[4];
#endif

#if HAKMEM_DEBUG_COUNTERS
#define HAK_PATHDBG_INC(arr, idx) do { if (g_path_debug_enabled) { (arr)[(idx)]++; } } while(0)
#define HAK_ULTRADBG_INC(arr, idx) do { (arr)[(idx)]++; } while(0)
#else
#define HAK_PATHDBG_INC(arr, idx) do { (void)(idx); } while(0)
#define HAK_ULTRADBG_INC(arr, idx) do { (void)(idx); } while(0)
#endif
// Simple scalar debug increment (no-op when HAKMEM_DEBUG_COUNTERS=0)
#if HAKMEM_DEBUG_COUNTERS
#define HAK_DBG_INC(var) do { (var)++; } while(0)
#else
#define HAK_DBG_INC(var) do { (void)0; } while(0)
#endif
// Return helper: record tiny alloc stat (guarded) then return pointer
static inline void tiny_debug_track_alloc_ret(int cls, void* ptr);

// ========== HAK_RET_ALLOC: Single Definition Point ==========
// Choose implementation based on HAKMEM_TINY_HEADERLESS or HAKMEM_TINY_HEADER_CLASSIDX
// - Headerless enabled: Return base directly (no header write)
// - Phase 7 enabled: Write header and return user pointer (base+1)
// - Phase 7 disabled: Legacy behavior (stats + route + return)

#if HAKMEM_TINY_HEADERLESS
    // Headerless: No header write, user = base
    // Ultra-fast inline macro (1-2 instructions)
    #define HAK_RET_ALLOC(cls, base_ptr) do { \
        /* No header write needed for Headerless mode */ \
        return (base_ptr); \
    } while(0)

#elif HAKMEM_TINY_HEADER_CLASSIDX
    #if HAKMEM_BUILD_RELEASE
        // Phase E1-CORRECT: ALL classes have 1-byte headers (including C7)
        // Ultra-fast inline macro (3-4 instructions)
        #define HAK_RET_ALLOC(cls, base_ptr) do { \
            tiny_header_write_for_alloc((base_ptr), (cls)); \
            hak_base_ptr_t _base = HAK_BASE_FROM_RAW(base_ptr); \
            hak_user_ptr_t _user = ptr_base_to_user(_base, (cls)); \
            return (void*)HAK_USER_TO_RAW(_user); \
        } while(0)
    #else
        // Debug: Keep full validation via tiny_region_id_write_header() + operation logging
        #define HAK_RET_ALLOC(cls, ptr) do { \
            extern _Atomic uint64_t g_debug_op_count; \
            extern __thread TinyTLSSLL g_tls_sll[]; \
            void* base_ptr = (ptr); \
            void* user_ptr = tiny_region_id_write_header(base_ptr, (cls)); \
            uint64_t op = atomic_fetch_add(&g_debug_op_count, 1); \
            if (op < 50 && (cls) == 1) { \
                fprintf(stderr, "[OP#%04lu ALLOC] cls=%d ptr=%p base=%p from=alloc tls_count=%u\n", \
                        (unsigned long)op, (cls), user_ptr, base_ptr, \
                        g_tls_sll[(cls)].count); \
                fflush(stderr); \
            } \
            return user_ptr; \
        } while(0)
    #endif
#else
    // Legacy: Stats and routing before return
    #ifdef HAKMEM_ENABLE_STATS
        // Optional: sampling（ビルド時に有効化）。ホットパスは直接インライン呼び出し（間接分岐なし）。
        #ifdef HAKMEM_TINY_STAT_SAMPLING
            static __thread unsigned g_tls_stat_accum_alloc[TINY_NUM_CLASSES];
            static int g_stat_rate_lg = 0;  // 0=毎回、それ以外=2^lgごと
            static inline __attribute__((always_inline)) void hkm_stat_alloc(int cls) {
                if (__builtin_expect(g_stat_rate_lg == 0, 1)) { stats_record_alloc(cls); return; }
                unsigned m = (1u << g_stat_rate_lg) - 1u;
                if (((++g_tls_stat_accum_alloc[cls]) & m) == 0u) stats_record_alloc(cls);
            }
        #else
            static inline __attribute__((always_inline)) void hkm_stat_alloc(int cls) { stats_record_alloc(cls); }
        #endif
        #define HAK_RET_ALLOC(cls, ptr) do { \
            tiny_debug_track_alloc_ret((cls), (ptr)); \
            hkm_stat_alloc((cls)); \
            ROUTE_COMMIT((cls), 0x7F); \
            return (ptr); \
        } while(0)
    #else
        #define HAK_RET_ALLOC(cls, ptr) do { \
            tiny_debug_track_alloc_ret((cls), (ptr)); \
            ROUTE_COMMIT((cls), 0x7F); \
            return (ptr); \
        } while(0)
    #endif
#endif  // HAKMEM_TINY_HEADER_CLASSIDX

// Free-side stats: compile-time zero when stats disabled
#ifdef HAKMEM_ENABLE_STATS
#define HAK_STAT_FREE(cls) do { stats_record_free((cls)); } while(0)
#else
#define HAK_STAT_FREE(cls) do { } while(0)
#endif