diff --git a/core/box/hak_wrappers.inc.h b/core/box/hak_wrappers.inc.h index c41307f6..843fd1a1 100644 --- a/core/box/hak_wrappers.inc.h +++ b/core/box/hak_wrappers.inc.h @@ -82,13 +82,9 @@ void* malloc(size_t size) { } // Now safe to call getenv/fprintf/dlopen (will use __libc_malloc if needed) - // Cache getenv result to avoid 8.51% CPU overhead on hot path - static _Atomic int debug_enabled = -1; // -1 = uninitialized + extern int g_sfc_debug; static _Atomic int debug_count = 0; - if (__builtin_expect(debug_enabled < 0, 0)) { - debug_enabled = (getenv("HAKMEM_SFC_DEBUG") != NULL) ? 1 : 0; - } - if (debug_enabled && debug_count < 100) { + if (__builtin_expect(g_sfc_debug, 0) && debug_count < 100) { int n = atomic_fetch_add(&debug_count, 1); if (n < 20) fprintf(stderr, "[SFC_DEBUG] malloc(%zu)\n", size); } diff --git a/core/hakmem_tiny_config.h b/core/hakmem_tiny_config.h index 3dcf7cde..6d2b93fe 100644 --- a/core/hakmem_tiny_config.h +++ b/core/hakmem_tiny_config.h @@ -144,6 +144,9 @@ int tiny_cap_max_for_class(int class_idx); // SFC Feature Flag (A/B testing) // ENV: HAKMEM_SFC_ENABLE (default: 0, OFF) extern int g_sfc_enabled; +// SFC Debug Flag (init-time cache) +// ENV: HAKMEM_SFC_DEBUG=1 (enable debug logging) +extern int g_sfc_debug; // SFC Default Configuration (can be overridden via ENV) // Phase 10: Aggressive SFC defaults to maximize front cache hit rate diff --git a/core/hakmem_tiny_sfc.c b/core/hakmem_tiny_sfc.c index 919e6ae9..682d119a 100644 --- a/core/hakmem_tiny_sfc.c +++ b/core/hakmem_tiny_sfc.c @@ -33,6 +33,7 @@ sfc_stats_t g_sfc_stats[TINY_NUM_CLASSES] = {0}; // ============================================================================ int g_sfc_enabled = 1; // Default: ON (bench-focused; A/B via HAKMEM_SFC_ENABLE) +int g_sfc_debug = 0; // Set once at init from HAKMEM_SFC_DEBUG static int g_sfc_default_capacity = SFC_DEFAULT_CAPACITY; static int g_sfc_default_refill = SFC_DEFAULT_REFILL_COUNT; @@ -47,6 +48,10 @@ static int g_sfc_refill_override[TINY_NUM_CLASSES] = {0}; // ============================================================================ void sfc_init(void) { + // Cache debug flag once (hot paths reuse g_sfc_debug) + const char* env_debug = getenv("HAKMEM_SFC_DEBUG"); + g_sfc_debug = (env_debug && *env_debug && *env_debug != '0') ? 1 : 0; + // Parse ENV: HAKMEM_SFC_ENABLE const char* env_enable = getenv("HAKMEM_SFC_ENABLE"); if (env_enable && *env_enable && *env_enable != '0') { @@ -120,8 +125,7 @@ void sfc_init(void) { static int debug_printed = 0; if (!debug_printed) { debug_printed = 1; - const char* env_debug = getenv("HAKMEM_SFC_DEBUG"); - if (env_debug && *env_debug && *env_debug != '0') { + if (g_sfc_debug) { fprintf(stderr, "[SFC] Initialized: enabled=%d, default_cap=%d, default_refill=%d\n", g_sfc_enabled, g_sfc_default_capacity, g_sfc_default_refill); for (int cls = 0; cls < TINY_NUM_CLASSES; cls++) { diff --git a/core/tiny_alloc_fast_sfc.inc.h b/core/tiny_alloc_fast_sfc.inc.h index 3df06637..c68b3460 100644 --- a/core/tiny_alloc_fast_sfc.inc.h +++ b/core/tiny_alloc_fast_sfc.inc.h @@ -108,12 +108,9 @@ static inline int sfc_free_push(int cls, void* ptr) { #if !HAKMEM_BUILD_RELEASE && defined(HAKMEM_SFC_DEBUG_LOG) // Debug logging (compile-time gated; zero cost in release) do { - static __thread int free_debug_enabled = -1; static __thread int free_debug_count = 0; - if (__builtin_expect(free_debug_enabled == -1, 0)) { - free_debug_enabled = getenv("HAKMEM_SFC_DEBUG") ? 1 : 0; - } - if (free_debug_enabled && free_debug_count < 20) { + extern int g_sfc_debug; + if (__builtin_expect(g_sfc_debug, 0) && free_debug_count < 20) { free_debug_count++; extern int g_sfc_enabled; fprintf(stderr, "[SFC_FREE_PUSH] cls=%d, ptr=%p, cnt=%u, cap=%u, will_succeed=%d, enabled=%d\n", diff --git a/core/tiny_free_fast.inc.h b/core/tiny_free_fast.inc.h index 341997e2..d4957e08 100644 --- a/core/tiny_free_fast.inc.h +++ b/core/tiny_free_fast.inc.h @@ -98,12 +98,9 @@ static inline int tiny_free_fast_ss(SuperSlab* ss, int slab_idx, void* base, uin // Debug: Track tiny_free_fast_ss calls #if !HAKMEM_BUILD_RELEASE - static __thread int free_ss_debug_enabled = -1; static __thread int free_ss_debug_count = 0; - if (__builtin_expect(free_ss_debug_enabled == -1, 0)) { - free_ss_debug_enabled = getenv("HAKMEM_SFC_DEBUG") ? 1 : 0; - } - if (free_ss_debug_enabled && free_ss_debug_count < 20) { + extern int g_sfc_debug; + if (__builtin_expect(g_sfc_debug, 0) && free_ss_debug_count < 20) { free_ss_debug_count++; int is_same = tiny_free_is_same_thread_ss(ss, slab_idx, my_tid); extern int g_sfc_enabled; diff --git a/docs/analysis/ENV_CLEANUP_PLAN.md b/docs/analysis/ENV_CLEANUP_PLAN.md index 43fec9f8..829179bb 100644 --- a/docs/analysis/ENV_CLEANUP_PLAN.md +++ b/docs/analysis/ENV_CLEANUP_PLAN.md @@ -1,411 +1,426 @@ -# OBSOLETE ENV Cleanup Plan +# OBSOLETE/ACTIVE ENV Cleanup Plan (file-by-file) ## Summary -- **Total ENV vars in codebase**: 221 -- **Potentially OBSOLETE vars**: 54 -- **Files affected**: 73 -- **Safe to remove immediately**: 18 (Priority 1) -- **Need verification**: 36 (Priority 2-3) +- Baseline: **221** ENV variables from the initial sweep (Nov 26); current recount (includes `.inc` helpers) shows **~279** unique getenv names. +- Box boundaries: move getenv calls to init boundaries where possible; keep hot paths free of repeated getenvs. +- Active & non-removable: **Ultra**, **BG**, **HeapV2/FrontV2**, **SFC**, **Thread Cache**, **Ring (L25)** — all are compiled and used; only A/B gating allowed. +- Docs-only: **21** proposal-only variables have zero getenv hits (see `SAFE_TO_DELETE_ENV_VARS.md`) and can be dropped from docs with no rollback risk. +- Goal: reduce production-facing ENV surface without breaking rollback; keep debug knobs behind a single boundary per box. ---- +## Priorities +1. **SFC_DEBUG consolidation** (Box boundary): single init-time getenv in `core/hakmem_tiny_sfc.c`, reuse `g_sfc_debug` in `core/tiny_alloc_fast_sfc.inc.h`, `core/tiny_free_fast.inc.h`, `core/box/hak_wrappers.inc.h`. +2. **Doc hygiene**: remove the 21 docs-only names from `docs/specs/ENV_VARS*.md`; keep a short changelog entry noting they never existed in runtime code. +3. **Debug gating**: corral *_DEBUG/_TRACE/_STATS getenvs into debug-only paths or init-time caches (avoid hot-path getenv per call). +4. **Verification guardrails**: keep Ultra/BG/HeapV2 toggles intact; any deprecation must be #ifdef/A-B gated with a rollback env. -## Priority 1: 100% Safe Removals (Already Removed Code) +## Feature Decisions (keep vs. change) +- **KEEP (active)**: Ultra (`core/ultra/*`, `core/box/ultra_slim_alloc_box.h`), BG (`core/hakmem_batch.c`, `core/hakmem_l25_pool.c`), HeapV2/FrontV2 (`core/front/tiny_heap_v2.h`, `core/tiny_alloc_fast.inc.h`), SFC (`core/hakmem_tiny_sfc.c`), TC/Ring (`core/hakmem_l25_pool.c`, `core/box/pool_init_api.inc.h`). +- **CLEAN**: Duplicate `HAKMEM_SFC_DEBUG` getenvs; legacy doc-only set (21 vars) from specs/papers. +- **DEFER**: Any removal of Ultra/HeapV2/BG toggles until explicit user approval; these are part of the active Box stack. -These ENV variables reference features that were **completely removed** in commits bcfb4f6b5 and 225b6fcc7 but ENV checks were left behind: +## File-by-File Checkpoints (actionable) +- **SFC (Shared Frontend Cache)** + - `core/hakmem_tiny_sfc.c:51,62,71,123,144` — keep enable/capacity/refill/debug/stats; cache `HAKMEM_SFC_DEBUG` here. + - `core/tiny_alloc_fast_sfc.inc.h:114`, `core/tiny_free_fast.inc.h:104`, `core/box/hak_wrappers.inc.h:89` — switch to cached `g_sfc_debug`. + - `core/tiny_alloc_fast.inc.h:477` — `HAKMEM_SFC_CASCADE_PCT` stays feature-tunable. +- **BG system** + - `core/hakmem_batch.c:73` (`HAKMEM_BATCH_BG`) — active default; keep. + - `core/hakmem_l25_pool.c:741-743` (`HAKMEM_L25_BG_DRAIN`, `HAKMEM_L25_BG_MS`) — keep; optionally cache at init. +- **HeapV2/FrontV2** + - `core/front/tiny_heap_v2.h:45,58,87,119` — class mask/leftover/debug toggles; keep A/B path. + - `core/tiny_alloc_fast.inc.h:167,352` and `core/hakmem_tiny.c:578` — stats/enable toggles; keep. + - `core/box/front_metrics_box.*` — metrics/dump toggles; keep. +- **Ultra** + - `core/front/tiny_ultrafront.h:39`, `core/ultra/tiny_ultra_heap.c:23,180`, `core/ultra/tiny_ultra_page_arena.c:71`, `core/box/ultra_slim_alloc_box.h:87,226`, `core/box/hak_core_init.inc.h:279` — keep experimental toggles; require #ifdef rollback if changed. +- **Ring/TC** + - `core/hakmem_l25_pool.c:718,724,745`, `core/box/pool_init_api.inc.h:60,66` — ring controls (active). + - `core/hakmem_l25_pool.c:737,739`, `core/box/pool_init_api.inc.h:72-78` — TC controls (active); no removal. + - `core/tiny_debug_ring.c:195,231` — debug-only; gate behind build/debug. +- **Doc-only cleanups** + - Remove mentions of the 21 docs-only names (see `SAFE_TO_DELETE_ENV_VARS.md`) from `docs/specs/ENV_VARS.md` and `docs/specs/ENV_VARS_COMPLETE.md` when touched; no code changes required. -### Removed Features: -- **UltraHot** (core/front/tiny_ultra_hot.h - removed bcfb4f6b5) -- **RingCache** (core/front/tiny_ring_cache.* - removed bcfb4f6b5) -- **FrontC23** (core/front/tiny_front_c23.h - removed bcfb4f6b5) -- **Class5 Hotpath** (removed bcfb4f6b5) +## Debug/Stats Gating Guidance +- Collapse hot-path debug getenvs into init-time caches (`static int g_* = -1;` pattern) to honor Fail-Fast without repeated getenv. +- Keep production surface small: gate *_DEBUG/_TRACE/_DUMP behind `HAKMEM_BUILD_RELEASE` or init-time knobs in `hak_core_init.inc.h`. +- Prefer one-shot logging (Box Principle #4) rather than repeated tracing in hot paths. -### ENV Variables (18 vars, SAFE TO DELETE): - -**No references found in current codebase** - these can be removed immediately: +## Verification Notes +- Ultra/BG/HeapV2 toggles are **active**; treat any deletion as a feature-removal project with A/B fallback (`HAKMEM_TINY_ULTRA_DEBUG`, `HAKMEM_BATCH_BG`, `HAKMEM_TINY_HEAP_V2_*`). +- Doc-only list was confirmed with `rg` diff (`comm -23 docs_env code_env`); zero getenv hits. +- Count drift (221 → ~279) comes from `.inc` helpers now included in the scan; keep 221 as the baseline metric but track the expanded map below. +## Appendix: Complete getenv() map (sorted by path) ``` -HAKMEM_TINY_ULTRA_HOT ✅ Removed -HAKMEM_TINY_ULTRA_HOT_MAX_SIZE ✅ Removed -HAKMEM_TINY_ULTRA_HOT_STATS ✅ Removed -HAKMEM_TINY_HOT_RING_ENABLE ✅ Removed -HAKMEM_TINY_HOT_RING_C2 ✅ Removed -HAKMEM_TINY_HOT_RING_C3 ✅ Removed -HAKMEM_TINY_HOT_RING_C5 ✅ Removed -HAKMEM_TINY_HOT_RING_CASCADE ✅ Removed -HAKMEM_TINY_FRONT_C23 ✅ Removed -HAKMEM_TINY_CLASS5_HOTPATH ✅ Removed -HAKMEM_TINY_CLASS5_STATS_DUMP ✅ Removed +core/box/ace_pool_connector.c:30: const char* ace_env = getenv("HAKMEM_ACE_ENABLED"); +core/box/external_guard_box.h:34: const char* e = getenv("HAKMEM_EXTERNAL_GUARD_MINCORE"); +core/box/external_guard_box.h:44: const char* e = getenv("HAKMEM_EXTERNAL_GUARD_LOG"); +core/box/external_guard_box.h:153: const char* e = getenv("HAKMEM_EXTERNAL_GUARD_STATS"); +core/box/free_local_box.c:37: const char* e = getenv("HAKMEM_TINY_SLL_DIAG"); +core/box/free_local_box.c:84: const char* e = getenv("HAKMEM_TINY_SLL_DIAG"); +core/box/free_local_box.c:163: const char* e = getenv("HAKMEM_TINY_FREELIST_MASK"); +core/box/free_local_box.c:185: const char* e = getenv("HAKMEM_SS_FREE_DEBUG"); +core/box/front_metrics_box.c:39: const char* env = getenv("HAKMEM_TINY_FRONT_METRICS"); +core/box/front_metrics_box.c:54: const char* dump_env = getenv("HAKMEM_TINY_FRONT_DUMP"); +core/box/front_metrics_box.h:144: const char* env = getenv("HAKMEM_TINY_FRONT_DISABLE_HEAPV2"); +core/box/hak_core_init.inc.h:59: const char* dbg = getenv("HAKMEM_DEBUG_SEGV"); +core/box/hak_core_init.inc.h:87: char* evo_sample_str = getenv("HAKMEM_EVO_SAMPLE"); +core/box/hak_core_init.inc.h:155: char* bt = getenv("HAKMEM_BENCH_TINY_ONLY"); +core/box/hak_core_init.inc.h:167: char* lds = getenv("HAKMEM_LD_SAFE"); +core/box/hak_core_init.inc.h:169: if (!getenv("HAKMEM_TINY_TLS_SLL")) { +core/box/hak_core_init.inc.h:172: if (!getenv("HAKMEM_TINY_USE_SUPERSLAB")) { +core/box/hak_core_init.inc.h:179: char* safe_free_env = getenv("HAKMEM_SAFE_FREE"); +core/box/hak_core_init.inc.h:194: char* invlog = getenv("HAKMEM_INVALID_FREE_LOG"); +core/box/hak_core_init.inc.h:202: char* inv = getenv("HAKMEM_INVALID_FREE"); +core/box/hak_core_init.inc.h:262: char* sr_env = getenv("HAKMEM_SITE_RULES"); +core/box/hak_core_init.inc.h:275: char* tf = getenv("HAKMEM_TINY_FLUSH_ON_EXIT"); +core/box/hak_core_init.inc.h:279: char* ud = getenv("HAKMEM_TINY_ULTRA_DEBUG"); +core/box/hak_core_init.inc.h:285: if (g_flush_tiny_on_exit || g_ultra_debug_on_exit || getenv("HAKMEM_TINY_PATH_DEBUG")) { +core/box/hak_free_api.inc.h:22: const char* e = getenv("HAKMEM_FREE_ROUTE_TRACE"); +core/box/hak_free_api.inc.h:46: const char* e = getenv("HAKMEM_SUPER_REG_REQTRACE"); +core/box/hak_free_api.inc.h:87: const char* e = getenv("HAKMEM_FREE_WRAP_TRACE"); +core/box/hak_free_api.inc.h:102: const char* e = getenv("HAKMEM_BENCH_FAST_FRONT"); +core/box/hak_free_api.inc.h:335: static int g_bc_l25_en_free = -1; if (g_bc_l25_en_free == -1) { const char* e = getenv("HAKMEM_BIGCACHE_L25"); g_bc_l25_en_free = (e && atoi(e) != 0) ? 1 : 0; } +core/box/hak_wrappers.inc.h:89: debug_enabled = (getenv("HAKMEM_SFC_DEBUG") != NULL) ? 1 : 0; +core/box/hak_wrappers.inc.h:118: const char* lds = getenv("HAKMEM_LD_SAFE"); +core/box/hak_wrappers.inc.h:196: do { static int on=-1; if (on==-1){ const char* e=getenv("HAKMEM_FREE_WRAP_TRACE"); on=(e&&*e&&*e!='0')?1:0;} if(on){ fprintf(stderr,"[WRAP_FREE_ENTER] ptr=%p depth=%d init=%d\n", ptr, g_hakmem_lock_depth, g_initializing); } } while(0); +core/box/hak_wrappers.inc.h:366: const char* lds = getenv("HAKMEM_LD_SAFE"); +core/box/mailbox_box.c:61: const char* e = getenv("HAKMEM_TINY_RF_TRACE"); +core/box/mailbox_box.c:129: const char* e = getenv("HAKMEM_TINY_MAILBOX_SLOWDISC"); +core/box/mailbox_box.c:136: const char* p = getenv("HAKMEM_TINY_MAILBOX_SLOWDISC_PERIOD"); +core/box/mailbox_box.c:162: const char* e = getenv("HAKMEM_TINY_MAILBOX_TRACE"); +core/box/mailbox_box.c:164: const char* l = getenv("HAKMEM_TINY_MAILBOX_TRACE_LIMIT"); +core/box/mailbox_box.c:172: const char* e = getenv("HAKMEM_TINY_MAILBOX_SLOWDISC"); +core/box/mailbox_box.c:176: const char* p = getenv("HAKMEM_TINY_MAILBOX_SLOWDISC_PERIOD"); +core/box/pagefault_telemetry_box.c:17: const char* env = getenv("HAKMEM_TINY_PAGEFAULT_TELEMETRY"); +core/box/pagefault_telemetry_box.c:29: const char* dump_env = getenv("HAKMEM_TINY_PAGEFAULT_DUMP"); +core/box/pool_init_api.inc.h:52: const char* e_tls = getenv("HAKMEM_POOL_TLS_FREE"); +core/box/pool_init_api.inc.h:54: const char* e_wrap = getenv("HAKMEM_WRAP_L2"); +core/box/pool_init_api.inc.h:56: const char* e_minb = getenv("HAKMEM_POOL_MIN_BUNDLE"); +core/box/pool_init_api.inc.h:58: const char* e_mix = getenv("HAKMEM_SHARD_MIX"); +core/box/pool_init_api.inc.h:60: const char* e_ring = getenv("HAKMEM_POOL_TLS_RING"); +core/box/pool_init_api.inc.h:62: const char* e_hdr = getenv("HAKMEM_HDR_LIGHT"); +core/box/pool_init_api.inc.h:64: const char* e_probe = getenv("HAKMEM_TRYLOCK_PROBES"); +core/box/pool_init_api.inc.h:66: const char* e_div = getenv("HAKMEM_RING_RETURN_DIV"); +core/box/pool_init_api.inc.h:68: const char* e_lo = getenv("HAKMEM_TLS_LO_MAX"); +core/box/pool_init_api.inc.h:70: const char* e_cs = getenv("HAKMEM_POOL_COUNT_SAMPLE"); +core/box/pool_init_api.inc.h:72: const char* e_tc = getenv("HAKMEM_TC_ENABLE"); +core/box/pool_init_api.inc.h:74: const char* e_tcu = getenv("HAKMEM_TC_UNBOUNDED"); +core/box/pool_init_api.inc.h:76: const char* e_tcm = getenv("HAKMEM_TC_DRAIN_MAX"); +core/box/pool_init_api.inc.h:78: const char* e_tct = getenv("HAKMEM_TC_DRAIN_TRIGGER"); +core/box/pool_init_api.inc.h:80: const char* e_mf2 = getenv("HAKMEM_MF2_ENABLE"); +core/box/pool_init_api.inc.h:84: const char* e_maxq = getenv("HAKMEM_MF2_MAX_QUEUES"); +core/box/pool_init_api.inc.h:86: const char* e_lease = getenv("HAKMEM_MF2_LEASE_MS"); +core/box/pool_init_api.inc.h:88: const char* e_idle = getenv("HAKMEM_MF2_IDLE_THRESHOLD_US"); +core/box/ss_ace_box.c:53: const char* env = getenv("HAKMEM_ACE_PROFILE"); +core/box/ss_ace_box.c:262: const char* ace_debug = getenv("HAKMEM_ACE_DEBUG"); +core/box/ss_allocation_box.c:85: const char* e = getenv("HAKMEM_TINY_SS_FAULT_RATE"); +core/box/ss_allocation_box.c:104: char* maxmb = getenv("HAKMEM_TINY_SS_MAX_MB"); +core/box/ss_allocation_box.c:108: char* minmb = getenv("HAKMEM_TINY_SS_MIN_MB"); +core/box/ss_allocation_box.c:113: const char* force_lg_env = getenv("HAKMEM_TINY_SS_FORCE_LG"); +core/box/ss_allocation_box.c:122: const char* precharge_env = getenv("HAKMEM_TINY_SS_PRECHARGE"); +core/box/ss_allocation_box.c:132: const char* cache_env = getenv("HAKMEM_TINY_SS_CACHE"); +core/box/ss_allocation_box.c:163: const char* populate_env = getenv("HAKMEM_TINY_SS_POPULATE_ONCE"); +core/box/ss_allocation_box.c:181: const char* e = getenv("HAKMEM_SS_PREWARM_DEBUG"); +core/box/ss_allocation_box.c:300: const char* e = getenv("HAKMEM_SS_FREE_DEBUG"); +core/box/ss_hot_prewarm_box.c:43: const char* all_env = getenv("HAKMEM_TINY_PREWARM_ALL"); +core/box/ss_legacy_backend_box.c:39: const char* e = getenv("HAKMEM_TINY_SS_LEGACY_HINT"); +core/box/ss_unified_backend_box.c:140: const char* e = getenv("HAKMEM_TINY_SS_SHARED"); +core/box/ss_unified_backend_box.c:145: const char* e = getenv("HAKMEM_TINY_SS_LEGACY_FALLBACK"); +core/box/ss_unified_backend_box.c:151: const char* e = getenv("HAKMEM_TINY_SS_C23_UNIFIED"); +core/box/tiny_near_empty_box.c:18: const char* e = getenv("HAKMEM_TINY_SS_PACK_C23"); +core/box/tiny_near_empty_box.c:33: const char* env = getenv("HAKMEM_TINY_NEAREMPTY_PCT"); +core/box/tiny_near_empty_box.c:111: const char* dump = getenv("HAKMEM_TINY_NEAREMPTY_DUMP"); +core/box/tls_sll_box.h:111: const char* e = getenv("HAKMEM_TINY_SLL_DIAG"); +core/box/tls_sll_box.h:185: const char* e = getenv("HAKMEM_TINY_SLL_DIAG"); +core/box/tls_sll_box.h:322: const char* e = getenv("HAKMEM_TINY_SLL_SAFEHEADER"); +core/box/tls_sll_box.h:326: const char* r = getenv("HAKMEM_TINY_SLL_RING"); +core/box/tls_sll_box.h:443: const char* r = getenv("HAKMEM_TINY_SLL_RING"); +core/box/tls_sll_box.h:488: const char* e = getenv("HAKMEM_TINY_SLL_CANARY_FAST"); +core/box/tls_sll_box.h:528: const char* r = getenv("HAKMEM_TINY_SLL_RING"); +core/box/tls_sll_drain_box.h:40: const char* env = getenv("HAKMEM_TINY_SLL_DRAIN_ENABLE"); +core/box/tls_sll_drain_box.h:57: const char* env = getenv("HAKMEM_TINY_SLL_DRAIN_INTERVAL"); +core/box/tls_sll_drain_box.h:121: const char* env = getenv("HAKMEM_TINY_SLL_DRAIN_DEBUG"); +core/box/ultra_slim_alloc_box.h:87: const char* e = getenv("HAKMEM_TINY_ULTRA_SLIM"); +core/box/ultra_slim_alloc_box.h:226: const char* e = getenv("HAKMEM_ULTRA_SLIM_STATS"); +core/front/malloc_tiny_fast.h:41: const char* e = getenv("HAKMEM_FRONT_GATE_UNIFIED"); +core/front/tiny_heap_v2.h:45: const char* e = getenv("HAKMEM_TINY_FRONT_V2"); +core/front/tiny_heap_v2.h:58: const char* e = getenv("HAKMEM_TINY_HEAP_V2_CLASS_MASK"); +core/front/tiny_heap_v2.h:87: const char* e = getenv("HAKMEM_TINY_HEAP_V2_LEFTOVER_MODE"); +core/front/tiny_heap_v2.h:119: const char* e = getenv("HAKMEM_TINY_HEAP_V2_DEBUG"); +core/front/tiny_ultrafront.h:39: const char* e = getenv("HAKMEM_TINY_ULTRA_FRONT"); +core/front/tiny_unified_cache.h:68: const char* e = getenv("HAKMEM_TINY_UNIFIED_CACHE"); +core/hakmem.c:70: const char* dbg = getenv("HAKMEM_DEBUG_SEGV"); +core/hakmem.c:110:// Perf analysis showed getenv("HAKMEM_INVALID_FREE") consumed 43.96% of CPU time! +core/hakmem.c:150: const char* init_only = getenv("HAKMEM_FORCE_LIBC_ALLOC_INIT"); +core/hakmem.c:156: const char* force = getenv("HAKMEM_FORCE_LIBC_ALLOC"); +core/hakmem.c:160: const char* wrap = getenv("HAKMEM_WRAP_TINY"); +core/hakmem.c:185: const char* e = getenv("HAKMEM_LD_BLOCK_JEMALLOC"); +core/hakmem_ace_stats.c:16: const char* env = getenv("HAKMEM_ACE_SAMPLE"); +core/hakmem_batch.c:73: const char* e_bg = getenv("HAKMEM_BATCH_BG"); +core/hakmem_config.c:187: const char* free_policy_env = getenv("HAKMEM_FREE_POLICY"); +core/hakmem_config.c:198: const char* thp_env = getenv("HAKMEM_THP"); +core/hakmem_config.c:209: const char* verbose_env = getenv("HAKMEM_VERBOSE"); +core/hakmem_config.c:215: const char* disable_bigcache = getenv("HAKMEM_DISABLE_BIGCACHE"); +core/hakmem_config.c:220: const char* disable_elo = getenv("HAKMEM_DISABLE_ELO"); +core/hakmem_config.c:225: const char* disable_batch = getenv("HAKMEM_DISABLE_BATCH"); +core/hakmem_config.c:233: const char* mode_env = getenv("HAKMEM_MODE"); +core/hakmem_debug.c:153: const char* env = getenv("HAKMEM_TIMING"); +core/hakmem_elo.c:205: { const char* q = getenv("HAKMEM_QUIET"); if (!(q && strcmp(q, "1") == 0)) fprintf(stderr, "[ELO] Not enough eligible strategies (need 2, have %d)\n", eligible_count); } +core/hakmem_elo.c:228: { const char* q = getenv("HAKMEM_QUIET"); if (!(q && strcmp(q, "1") == 0)) fprintf(stderr, "[ELO] Completed %d pairwise comparisons\n", comparisons); } +core/hakmem_elo.c:254: { const char* q = getenv("HAKMEM_QUIET"); if (!(q && strcmp(q, "1") == 0)) fprintf(stderr, "[ELO] Strategy %d (%.0fKB) eliminated (rating: %.1f)\n", +core/hakmem_elo.c:266: { const char* q = getenv("HAKMEM_QUIET"); if (!(q && strcmp(q, "1") == 0)) fprintf(stderr, "\n[ELO] Statistics:\n"); } +core/hakmem_elo.c:267: { const char* q = getenv("HAKMEM_QUIET"); if (!(q && strcmp(q, "1") == 0)) fprintf(stderr, " Total selections: %lu\n", g_total_selections); } +core/hakmem_elo.c:268: { const char* q = getenv("HAKMEM_QUIET"); if (!(q && strcmp(q, "1") == 0)) fprintf(stderr, " Active strategies: "); } +core/hakmem_elo.c:273: { const char* q = getenv("HAKMEM_QUIET"); if (!(q && strcmp(q, "1") == 0)) fprintf(stderr, "%d/%d\n", active_count, g_num_strategies); } +core/hakmem_elo.c:280: { const char* q = getenv("HAKMEM_QUIET"); if (!(q && strcmp(q, "1") == 0)) { +core/hakmem_elo.c:306: { const char* q = getenv("HAKMEM_QUIET"); if (!(q && strcmp(q, "1") == 0)) fprintf(stderr, " %4d | %2d | %7.0fKB | %10.1f | %lu/%lu/%lu | %7lu | %s\n", +core/hakmem_evo.c:130: const char* preset = getenv("HAKMEM_PRESET"); +core/hakmem_internal.h:48: char* env = getenv("HAKMEM_QUIET"); \ +core/hakmem_internal.h:218: char* env = getenv("HAKMEM_ALLOW_MALLOC_FALLBACK"); +core/hakmem_l25_pool.c:636: const char* e = getenv("HAKMEM_L25_MIN_BUNDLE"); +core/hakmem_l25_pool.c:714: char* dz = getenv("HAKMEM_L25_DZ"); +core/hakmem_l25_pool.c:716: const char* e_wrap = getenv("HAKMEM_WRAP_L25"); +core/hakmem_l25_pool.c:718: const char* e_ring = getenv("HAKMEM_POOL_TLS_RING"); +core/hakmem_l25_pool.c:720: const char* e_probe = getenv("HAKMEM_TRYLOCK_PROBES"); +core/hakmem_l25_pool.c:722: const char* e_lo = getenv("HAKMEM_TLS_LO_MAX"); +core/hakmem_l25_pool.c:724: const char* e_div = getenv("HAKMEM_RING_RETURN_DIV"); +core/hakmem_l25_pool.c:726: const char* e_run = getenv("HAKMEM_L25_RUN_BLOCKS"); +core/hakmem_l25_pool.c:728: const char* e_rfac = getenv("HAKMEM_L25_RUN_FACTOR"); +core/hakmem_l25_pool.c:730: const char* e_mix = getenv("HAKMEM_SHARD_MIX"); +core/hakmem_l25_pool.c:732: const char* e_pref = getenv("HAKMEM_L25_PREF"); +core/hakmem_l25_pool.c:737: const char* e_tc = getenv("HAKMEM_L25_TC_SPILL"); +core/hakmem_l25_pool.c:739: const char* e_tcc = getenv("HAKMEM_L25_TC_CAP"); +core/hakmem_l25_pool.c:741: const char* e_bg = getenv("HAKMEM_L25_BG_DRAIN"); +core/hakmem_l25_pool.c:743: const char* e_bgms = getenv("HAKMEM_L25_BG_MS"); +core/hakmem_l25_pool.c:745: const char* e_rtr = getenv("HAKMEM_L25_RING_TRIGGER"); +core/hakmem_l25_pool.c:747: const char* e_inb = getenv("HAKMEM_L25_OWNER_INBOUND"); +core/hakmem_l25_pool.c:749: const char* e_ins = getenv("HAKMEM_L25_INBOUND_SLOTS"); +core/hakmem_l25_pool.c:754: const char* e_safe = getenv("HAKMEM_L25_REMOTE_SAFE"); +core/hakmem_learn_log.c:30: const char* s = getenv("HAKMEM_LEARN_SAMPLE"); +core/hakmem_learner.c:170: double tgt_mid = (getenv("HAKMEM_TARGET_HIT_MID") ? atof(getenv("HAKMEM_TARGET_HIT_MID")) : 0.65); +core/hakmem_learner.c:171: double tgt_lg = (getenv("HAKMEM_TARGET_HIT_LARGE") ? atof(getenv("HAKMEM_TARGET_HIT_LARGE")) : 0.55); +core/hakmem_learner.c:187: double w_miss = (getenv("HAKMEM_GAIN_W_MISS") ? atof(getenv("HAKMEM_GAIN_W_MISS")) : 1.0); +core/hakmem_learner.c:201: const char* ace_observe = getenv("HAKMEM_ACE_OBSERVE"); +core/hakmem_learner.c:203: const char* ace_debug = getenv("HAKMEM_ACE_DEBUG"); +core/hakmem_learner.c:223: const char* logf = getenv("HAKMEM_LOG_FILE"); +core/hakmem_learner.c:294: const char* dyn_auto = getenv("HAKMEM_DYN1_AUTO"); +core/hakmem_learner.c:295: const char* dyn2_auto = getenv("HAKMEM_DYN2_AUTO"); +core/hakmem_learner.c:408: const char* wlearn = getenv("HAKMEM_WMAX_LEARN"); +core/hakmem_learner.c:418: n_mid = parse_float_list(getenv("HAKMEM_WMAX_CANDIDATES_MID"), vals_mid, 8); +core/hakmem_learner.c:420: n_lg = parse_float_list(getenv("HAKMEM_WMAX_CANDIDATES_LARGE"), vals_lg, 8); +core/hakmem_learner.c:425: adopt_pct = (getenv("HAKMEM_WMAX_ADOPT_PCT") ? atof(getenv("HAKMEM_WMAX_ADOPT_PCT")) : 0.01); +core/hakmem_learner.c:521: const char* thp_learn = getenv("HAKMEM_THP_LEARN"); +core/hakmem_learner.c:527: const char* s = getenv("HAKMEM_THP_CANDIDATES"); +core/hakmem_learner.c:532: adopt_pct = (getenv("HAKMEM_THP_ADOPT_PCT") ? atof(getenv("HAKMEM_THP_ADOPT_PCT")) : 0.015); +core/hakmem_learner.c:585: const char* e = getenv("HAKMEM_LEARN"); +core/hakmem_policy.c:88: const char* e_mid = getenv("HAKMEM_WMAX_MID"); +core/hakmem_policy.c:93: const char* e_large = getenv("HAKMEM_WMAX_LARGE"); +core/hakmem_policy.c:100: const char* cap_mid = getenv("HAKMEM_CAP_MID"); +core/hakmem_policy.c:106: const char* cap_lg = getenv("HAKMEM_CAP_LARGE"); +core/hakmem_policy.c:114: const char* dyn1 = getenv("HAKMEM_MID_DYN1"); +core/hakmem_policy.c:120: const char* cap_dyn1 = getenv("HAKMEM_CAP_MID_DYN1"); +core/hakmem_policy.c:126: const char* dyn2 = getenv("HAKMEM_MID_DYN2"); +core/hakmem_policy.c:131: const char* cap_dyn2 = getenv("HAKMEM_CAP_MID_DYN2"); +core/hakmem_prof.c:18: const char* env = getenv("HAKMEM_PROF"); +core/hakmem_prof.c:21: const char* sm = getenv("HAKMEM_PROF_SAMPLE"); +core/hakmem_shared_pool.c:29: const char* env = getenv("HAKMEM_SHARED_POOL_LOCK_STATS"); +core/hakmem_shared_pool.c:82: const char* env = getenv("HAKMEM_SHARED_POOL_STAGE_STATS"); +core/hakmem_shared_pool.c:782: const char* e = getenv("HAKMEM_SS_ACQUIRE_DEBUG"); +core/hakmem_shared_pool.c:830: const char* e = getenv("HAKMEM_SS_EMPTY_REUSE"); +core/hakmem_shared_pool.c:841: const char* e = getenv("HAKMEM_SS_EMPTY_SCAN_LIMIT"); +core/hakmem_shared_pool.c:1059: const char* env = getenv("HAKMEM_TINY_TENSION_DRAIN_ENABLE"); +core/hakmem_shared_pool.c:1062: const char* thresh_env = getenv("HAKMEM_TINY_TENSION_DRAIN_THRESHOLD"); +core/hakmem_shared_pool.c:1219: const char* e = getenv("HAKMEM_SS_FREE_DEBUG"); +core/hakmem_size_hist.c:12: const char* e = getenv("HAKMEM_HIST_SAMPLE"); +core/hakmem_smallmid.c:82: const char* env = getenv("HAKMEM_SMALLMID_ENABLE"); +core/hakmem_super_registry.c:55: const char* dbg_env = getenv("HAKMEM_SUPER_REG_DEBUG"); +core/hakmem_super_registry.c:140: const char* e = getenv("HAKMEM_SUPER_REG_DEBUG"); dbg_once = (e && *e && *e!='0'); +core/hakmem_super_registry.c:186: const char* max_cached_env = getenv("HAKMEM_SUPERSLAB_MAX_CACHED"); +core/hakmem_super_registry.c:187: const char* max_memory_env = getenv("HAKMEM_SUPERSLAB_MAX_MEMORY_MB"); +core/hakmem_super_registry.c:188: const char* ttl_env = getenv("HAKMEM_SUPERSLAB_TTL_SEC"); +core/hakmem_super_registry.c:272: const char* e = getenv("HAKMEM_SS_LRU_DEBUG"); +core/hakmem_super_registry.c:364: const char* e = getenv("HAKMEM_SS_LRU_DEBUG"); +core/hakmem_super_registry.c:482: const char* e = getenv("HAKMEM_SS_LRU_DEBUG"); +core/hakmem_super_registry.c:546: const char* e = getenv("HAKMEM_SS_PREWARM_DEBUG"); +core/hakmem_super_registry.c:625: const char* e = getenv("HAKMEM_SS_PREWARM_DEBUG"); +core/hakmem_super_registry.c:630: const char* env = getenv("HAKMEM_PREWARM_SUPERSLABS"); +core/hakmem_super_registry.h:125: const char* e = getenv("HAKMEM_SUPER_LOOKUP_DEBUG"); +core/hakmem_tiny.c:578: const char* env = getenv("HAKMEM_TINY_HEAP_V2_STATS"); +core/hakmem_tiny.c:606: const char* env = getenv("HAKMEM_TINY_ALLOC_1024_METRIC"); +core/hakmem_tiny.c:623: const char* env = getenv("HAKMEM_TINY_SLL_DIAG"); +core/hakmem_tiny.h:44: const char* env = getenv("HAKMEM_TINY_MAX_CLASS"); +core/hakmem_tiny_ace_guard_box.inc:60: const char* e = getenv("HAKMEM_TINY_GUARD"); +core/hakmem_tiny_ace_guard_box.inc:62: const char* ec = getenv("HAKMEM_TINY_GUARD_CLASS"); +core/hakmem_tiny_ace_guard_box.inc:64: const char* el = getenv("HAKMEM_TINY_GUARD_MAX"); +core/hakmem_tiny_alloc.inc:13: const char* e = getenv("HAKMEM_TINY_ALLOC_1024_METRIC"); +core/hakmem_tiny_alloc.inc:171: const char* e = getenv("HAKMEM_TINY_ALLOC_RING"); +core/hakmem_tiny_alloc_new.inc:36: const char* e = getenv("HAKMEM_TINY_ACTIVE_FIX"); +core/hakmem_tiny_alloc_new.inc:86: const char* e = getenv("HAKMEM_TINY_HEAP_V2_DEBUG"); +core/hakmem_tiny_alloc_new.inc:104: const char* e = getenv("HAKMEM_TINY_HEAP_V2_DEBUG"); +core/hakmem_tiny_alloc_new.inc:177: const char* e = getenv("HAKMEM_TINY_RETURN_FIRST"); +core/hakmem_tiny_alloc_new.inc:232: static int g_alloc_dbg = -1; if (__builtin_expect(g_alloc_dbg == -1, 0)) { const char* e=getenv("HAKMEM_TINY_ALLOC_DEBUG"); g_alloc_dbg = (e && atoi(e)!=0)?1:0; } +core/hakmem_tiny_alloc_new.inc:247: static int g_alloc_dbg2 = -1; if (__builtin_expect(g_alloc_dbg2 == -1, 0)) { const char* e=getenv("HAKMEM_TINY_ALLOC_DEBUG"); g_alloc_dbg2 = (e && atoi(e)!=0)?1:0; } +core/hakmem_tiny_alloc_new.inc:295: static int g_alloc_dbg3 = -1; if (__builtin_expect(g_alloc_dbg3 == -1, 0)) { const char* e=getenv("HAKMEM_TINY_ALLOC_DEBUG"); g_alloc_dbg3 = (e && atoi(e)!=0)?1:0; } +core/hakmem_tiny_background.inc:109: char* arf = getenv("HAKMEM_INT_ADAPT_REFILL"); +core/hakmem_tiny_background.inc:111: char* acp = getenv("HAKMEM_INT_ADAPT_CAPS"); +core/hakmem_tiny_background.inc:117: char* rb = getenv("HAKMEM_TINY_RSS_BUDGET_KB"); +core/hakmem_tiny_background.inc:119: char* st = getenv("HAKMEM_TINY_DIET_STEP"); +core/hakmem_tiny_background.inc:121: char* tt = getenv("HAKMEM_TINY_INT_TIGHT"); +core/hakmem_tiny_background.inc:133: char* it = getenv("HAKMEM_TINY_IDLE_TRIM_MS"); +core/hakmem_tiny_background.inc:135: char* iff = getenv("HAKMEM_TINY_IDLE_FLUSH"); +core/hakmem_tiny_config_box.inc:59: const char* tr = getenv("HAKMEM_TINY_SUPERSLAB_TRACE"); +core/hakmem_tiny_fastcache.inc.h:54: const char* e = getenv("HAKMEM_TINY_FAST_DEBUG"); +core/hakmem_tiny_fastcache.inc.h:56: const char* limit_env = getenv("HAKMEM_TINY_FAST_DEBUG_MAX"); +core/hakmem_tiny_fastcache.inc.h:109: const char* e = getenv("HAKMEM_TINY_FRONT_DIRECT"); +core/hakmem_tiny_free.inc:23: const char* s = getenv("HAKMEM_TINY_DRAIN_TO_SLL"); +core/hakmem_tiny_free.inc:195: const char* e = getenv("HAKMEM_TINY_FREE_TO_SS"); +core/hakmem_tiny_globals_box.inc:218: const char* env = getenv("HAKMEM_TINY_SS_ADOPT"); +core/hakmem_tiny_init.inc:21: char* preset_env = getenv("HAKMEM_TINY_PRESET"); +core/hakmem_tiny_init.inc:34: char* env = getenv("HAKMEM_USE_REGISTRY"); +core/hakmem_tiny_init.inc:43: char* wrap_env = getenv("HAKMEM_WRAP_TINY"); +core/hakmem_tiny_init.inc:47: char* wrap_refill_env = getenv("HAKMEM_WRAP_TINY_REFILL"); +core/hakmem_tiny_init.inc:52: char* rth = getenv("HAKMEM_TINY_REMOTE_DRAIN_THRESHOLD"); +core/hakmem_tiny_init.inc:54: char* rr = getenv("HAKMEM_TINY_REMOTE_DRAIN_TRYRATE"); +core/hakmem_tiny_init.inc:56: char* cs = getenv("HAKMEM_TINY_COUNT_SAMPLE"); +core/hakmem_tiny_init.inc:60: char* memdiet_env = getenv("HAKMEM_TINY_MEM_DIET"); +core/hakmem_tiny_init.inc:69: char* mag_env = getenv("HAKMEM_TINY_MAG_CAP"); +core/hakmem_tiny_init.inc:108: char* superslab_env = getenv("HAKMEM_TINY_USE_SUPERSLAB"); +core/hakmem_tiny_init.inc:125: const char* must_adopt = getenv("HAKMEM_TINY_MUST_ADOPT"); +core/hakmem_tiny_init.inc:133: char* tlslist_env = getenv("HAKMEM_TINY_TLS_LIST"); +core/hakmem_tiny_init.inc:140: char* sll_env = getenv("HAKMEM_TINY_TLS_SLL"); +core/hakmem_tiny_init.inc:147: char* c03 = getenv("HAKMEM_TINY_SLL_C03_ONLY"); +core/hakmem_tiny_init.inc:151: char* msk = getenv("HAKMEM_TINY_SLL_MASK"); +core/hakmem_tiny_init.inc:159: char* pd = getenv("HAKMEM_TINY_PATH_DEBUG"); +core/hakmem_tiny_init.inc:164: char* ub = getenv("HAKMEM_TINY_BUMP_SHADOW"); +core/hakmem_tiny_init.inc:166: char* bc = getenv("HAKMEM_TINY_BUMP_CHUNK"); +core/hakmem_tiny_init.inc:171: char* ro = getenv("HAKMEM_TINY_REFILL_ONE_ON_MISS"); +core/hakmem_tiny_init.inc:175: char* sllmul = getenv("HAKMEM_SLL_MULTIPLIER"); +core/hakmem_tiny_init.inc:188: char* us = getenv("HAKMEM_TINY_ULTRA_SIMPLE"); +core/hakmem_tiny_init.inc:202: char* pf = getenv("HAKMEM_TINY_PREFETCH"); +core/hakmem_tiny_init.inc:206: char* rmax = getenv("HAKMEM_TINY_REFILL_MAX"); +core/hakmem_tiny_init.inc:208: char* rmaxh = getenv("HAKMEM_TINY_REFILL_MAX_HOT"); +core/hakmem_tiny_init.inc:220: char* sr = getenv("HAKMEM_TINY_STAT_RATE_LG"); +core/hakmem_tiny_init.inc:234: char* sh = getenv("HAKMEM_TINY_SPILL_HYST"); +core/hakmem_tiny_init.inc:237: char* ultra_env = getenv("HAKMEM_TINY_ULTRA"); +core/hakmem_tiny_init.inc:241: char* uval = getenv("HAKMEM_TINY_ULTRA_VALIDATE"); +core/hakmem_tiny_init.inc:273: char* g = getenv("HAKMEM_TINY_REFILL_COUNT"); +core/hakmem_tiny_init.inc:277: char* h = getenv("HAKMEM_TINY_REFILL_COUNT_HOT"); +core/hakmem_tiny_init.inc:281: char* m = getenv("HAKMEM_TINY_REFILL_COUNT_MID"); +core/hakmem_tiny_init.inc:290: char* fast_env = getenv("HAKMEM_TINY_FAST"); +core/hakmem_tiny_init.inc:293: char* fast_cap_env = getenv("HAKMEM_TINY_FAST_CAP"); +core/hakmem_tiny_init.inc:319: const char* dbg_fast = getenv("HAKMEM_TINY_DEBUG_FAST0"); +core/hakmem_tiny_init.inc:326: const char* dbg_remote = getenv("HAKMEM_TINY_DEBUG_REMOTE_GUARD"); +core/hakmem_tiny_init.inc:330: const char* rf_force = getenv("HAKMEM_TINY_RF_FORCE_NOTIFY"); +core/hakmem_tiny_init.inc:335: const char* safe_free = getenv("HAKMEM_SAFE_FREE"); +core/hakmem_tiny_init.inc:339: const char* safe_free_strict = getenv("HAKMEM_SAFE_FREE_STRICT"); +core/hakmem_tiny_init.inc:343: const char* force_remote = getenv("HAKMEM_TINY_FORCE_REMOTE"); +core/hakmem_tiny_init.inc:352: const char* tr = getenv("HAKMEM_TINY_SUPERSLAB_TRACE"); +core/hakmem_tiny_init.inc:373: char* fc_env = getenv("HAKMEM_TINY_FASTCACHE"); +core/hakmem_tiny_init.inc:377: char* fe_env = getenv("HAKMEM_TINY_FRONTEND"); +core/hakmem_tiny_init.inc:383: char* q = getenv("HAKMEM_TINY_QUICK"); +core/hakmem_tiny_init.inc:390: char* ie = getenv("HAKMEM_INT_ENGINE"); +core/hakmem_tiny_init.inc:396: char* its = getenv("HAKMEM_INT_EVENT_TS"); +core/hakmem_tiny_init.inc:398: char* ism = getenv("HAKMEM_INT_SAMPLE"); +core/hakmem_tiny_lifecycle.inc:37: char* er = getenv("HAKMEM_TINY_SS_RESERVE"); +core/hakmem_tiny_lifecycle.inc:71: char* env = getenv("HAKMEM_TINY_TRIM_SS"); +core/hakmem_tiny_lifecycle.inc:79: char* env = getenv("HAKMEM_TINY_SS_PARTIAL"); +core/hakmem_tiny_lifecycle.inc:83: char* interval = getenv("HAKMEM_TINY_SS_PARTIAL_INTERVAL"); +core/hakmem_tiny_phase6_wrappers_box.inc:38: const char* e = getenv("HAKMEM_BENCH_FAST_FRONT"); +core/hakmem_tiny_publish_box.inc:48: const char* b = getenv("HAKMEM_TINY_BENCH_MODE"); +core/hakmem_tiny_publish_box.inc:116: const char* e = getenv("HAKMEM_TINY_RF_TRACE"); +core/hakmem_tiny_publish_box.inc:179: const char* s = getenv("HAKMEM_SS_LIVE_CAP"); +core/hakmem_tiny_publish_box.inc:193: const char* s = getenv("HAKMEM_HOT_SLOT"); +core/hakmem_tiny_sfc.c:51: const char* env_enable = getenv("HAKMEM_SFC_ENABLE"); +core/hakmem_tiny_sfc.c:62: const char* env_cap = getenv("HAKMEM_SFC_CAPACITY"); +core/hakmem_tiny_sfc.c:71: const char* env_refill = getenv("HAKMEM_SFC_REFILL_COUNT"); +core/hakmem_tiny_sfc.c:123: const char* env_debug = getenv("HAKMEM_SFC_DEBUG"); +core/hakmem_tiny_sfc.c:144: const char* env_dump = getenv("HAKMEM_SFC_STATS_DUMP"); +core/hakmem_tiny_slow.inc:80: static int g_alloc_dbg = -1; if (__builtin_expect(g_alloc_dbg == -1, 0)) { const char* e=getenv("HAKMEM_TINY_ALLOC_DEBUG"); g_alloc_dbg = (e && atoi(e)!=0)?1:0; } +core/hakmem_tiny_smallmag.inc.h:42: const char* e = getenv("HAKMEM_TINY_SMALL_MAG"); +core/hakmem_tiny_stats.c:22: const char* e = getenv("HAKMEM_TINY_DUMP_ATEXIT_ONLY"); +core/hakmem_tiny_stats.c:57: const char* s = getenv("HAKMEM_TINY_SUKESUKE"); +core/hakmem_tiny_stats.c:70: const char* s = getenv("HAKMEM_TINY_SUKESUKE"); +core/hakmem_tiny_stats.c:213: const char* on = getenv("HAKMEM_TINY_PATH_DEBUG"); +core/hakmem_tiny_stats.c:240: const char* on = getenv("HAKMEM_TINY_COUNTERS_DUMP"); +core/hakmem_tiny_stats.c:564: const char* on1 = getenv("HAKMEM_TINY_REFILL_DUMP"); +core/hakmem_tiny_stats.c:565: const char* on2 = getenv("HAKMEM_TINY_COUNTERS_DUMP"); +core/hakmem_tiny_superslab.c:142: const char* e = getenv("HAKMEM_TINY_SLL_DIAG"); +core/hakmem_tiny_superslab.c:661: const char* e = getenv("HAKMEM_TINY_SS_SHARED"); +core/hakmem_tiny_superslab.c:704: const char* e = getenv("HAKMEM_TINY_SS_FAULT_RATE"); +core/hakmem_tiny_superslab.c:722: char* maxmb = getenv("HAKMEM_TINY_SS_MAX_MB"); +core/hakmem_tiny_superslab.c:726: char* minmb = getenv("HAKMEM_TINY_SS_MIN_MB"); +core/hakmem_tiny_superslab.c:731: const char* force_lg_env = getenv("HAKMEM_TINY_SS_FORCE_LG"); +core/hakmem_tiny_superslab.c:740: const char* precharge_env = getenv("HAKMEM_TINY_SS_PRECHARGE"); +core/hakmem_tiny_superslab.c:750: const char* cache_env = getenv("HAKMEM_TINY_SS_CACHE"); +core/hakmem_tiny_superslab.c:783: const char* populate_env = getenv("HAKMEM_TINY_SS_POPULATE_ONCE"); +core/hakmem_tiny_superslab.c:801: const char* e = getenv("HAKMEM_SS_PREWARM_DEBUG"); +core/hakmem_tiny_superslab.c:1093: const char* e = getenv("HAKMEM_SS_FREE_DEBUG"); +core/hakmem_tiny_superslab.c:1471: const char* ace_debug = getenv("HAKMEM_ACE_DEBUG"); +core/hakmem_tiny_ultra_simple.inc:61: char* env = getenv("HAKMEM_TINY_REFILL_COUNT"); +core/hakmem_tiny_ultra_simple.inc:128: if (getenv("HAKMEM_SFC_DEBUG") && free_entry_count < 20) { +core/hakmem_tiny_ultra_simple.inc:160: if (getenv("HAKMEM_SFC_DEBUG") && ultra_free_debug_count < 20) { +core/hakmem_tiny_ultra_simple.inc:170: if (getenv("HAKMEM_SFC_DEBUG") && push_attempt_count < 20) { +core/hakmem_tiny_unified_stats.c:16: const char* env = getenv("HAKMEM_TINY_UNIFIED_SAMPLE"); +core/mid_tcache.h:16: const char* s = getenv("HAKMEM_MID_TC"); +core/mid_tcache.h:25: const char* s = getenv("HAKMEM_MID_TC_CAP"); +core/page_arena.h:144: const char* e = getenv("HAKMEM_PAGE_ARENA_ENABLE"); +core/page_arena.h:160: const char* e = getenv("HAKMEM_PAGE_ARENA_HOT_SIZE"); +core/page_arena.h:176: const char* e = getenv("HAKMEM_PAGE_ARENA_WARM_64K"); +core/page_arena.h:192: const char* e = getenv("HAKMEM_PAGE_ARENA_WARM_128K"); +core/page_arena.h:208: const char* e = getenv("HAKMEM_PAGE_ARENA_WARM_2M"); +core/pool_tls_arena.c:23: const char* s_init = getenv("HAKMEM_POOL_TLS_ARENA_MB_INIT"); +core/pool_tls_arena.c:24: const char* s_max = getenv("HAKMEM_POOL_TLS_ARENA_MB_MAX"); +core/pool_tls_arena.c:25: const char* s_gl = getenv("HAKMEM_POOL_TLS_ARENA_GROWTH_LEVELS"); +core/ptr_trace.h:70: const char* env = getenv("HAKMEM_PTR_TRACE_DUMP"); +core/ptr_trace.h:81: const char* env = getenv("HAKMEM_PTR_TRACE_VERBOSE"); +core/slab_handle.h:264: const char* e = getenv("HAKMEM_TINY_FREELIST_MASK"); +core/slab_handle.h:314: const char* e = getenv("HAKMEM_TINY_FREELIST_MASK"); +core/tiny_adaptive_sizing.c:27: const char* env = getenv("HAKMEM_ADAPTIVE_SIZING"); +core/tiny_adaptive_sizing.c:35: const char* log_env = getenv("HAKMEM_ADAPTIVE_LOG"); +core/tiny_alloc_fast.inc.h:46: const char* e = getenv("HAKMEM_TINY_ALLOC_1024_METRIC"); +core/tiny_alloc_fast.inc.h:137: const char* env = getenv("HAKMEM_TINY_PROFILE"); +core/tiny_alloc_fast.inc.h:167: const char* e = getenv("HAKMEM_TINY_HEAP_V2_STATS"); +core/tiny_alloc_fast.inc.h:352: const char* e = getenv("HAKMEM_TINY_FRONT_SLIM"); +core/tiny_alloc_fast.inc.h:477: const char* e = getenv("HAKMEM_SFC_CASCADE_PCT"); +core/tiny_alloc_fast.inc.h:639: const char* e = getenv("HAKMEM_TINY_SFC_CASCADE"); +core/tiny_alloc_fast_sfc.inc.h:114: free_debug_enabled = getenv("HAKMEM_SFC_DEBUG") ? 1 : 0; +core/tiny_debug.h:13: const char* e = getenv("HAKMEM_TINY_ALLOC_DEBUG"); +core/tiny_debug_ring.c:195: const char* env = getenv("HAKMEM_TINY_TRACE_RING"); +core/tiny_debug_ring.c:231: const char* e = getenv("HAKMEM_TINY_DUMP_RING_ATEXIT"); +core/tiny_failfast.c:18: const char* e = getenv("HAKMEM_TINY_REFILL_FAILFAST"); +core/tiny_fastcache.c:80: const char* env = getenv("HAKMEM_TINY_PROFILE"); +core/tiny_fastcache.c:211: env = getenv("HAKMEM_TINY_FAST_STATS"); +core/tiny_fastcache.h:72: const char* env = getenv("HAKMEM_TINY_PROFILE"); +core/tiny_free_fast.inc.h:104: free_ss_debug_enabled = getenv("HAKMEM_SFC_DEBUG") ? 1 : 0; +core/tiny_free_fast.inc.h:208: const char* e = getenv("HAKMEM_TINY_FREE_FAST"); +core/tiny_free_fast.inc.h:210: const char* to_ss = getenv("HAKMEM_TINY_FREE_TO_SS"); +core/tiny_free_fast_v2.inc.h:188: const char* e = getenv("HAKMEM_TINY_LARSON_FIX"); +core/tiny_mmap_gate.h:15: const char* s = getenv("HAKMEM_TINY_MUST_ADOPT"); +core/tiny_mmap_gate.h:28: const char* cd = getenv("HAKMEM_TINY_SS_ADOPT_COOLDOWN"); +core/tiny_publish.c:23: const char* e = getenv("HAKMEM_TINY_RF_TRACE"); +core/tiny_refill.h:32: const char* s = getenv("HAKMEM_TINY_REG_SCAN_MAX"); +core/tiny_refill.h:52: const char* s = getenv("HAKMEM_TINY_MID_REFILL_SIMPLE"); +core/tiny_refill.h:93: const char* e = getenv("HAKMEM_TINY_RF_TRACE"); +core/tiny_refill_opt.h:34: const char* e = getenv("HAKMEM_TINY_REFILL_OPT_DEBUG"); +core/tiny_refill_opt.h:173: const char* env = getenv("HAKMEM_TINY_REFILL_FAILFAST"); +core/tiny_remote.c:275: const char* e = getenv("HAKMEM_TINY_DISABLE_REMOTE"); +core/tiny_remote.c:528: const char* e = getenv("HAKMEM_TINY_REMOTE_DRAIN_THRESHOLD"); +core/tiny_remote.c:642: const char* side_env = getenv("HAKMEM_TINY_REMOTE_SIDE"); +core/tiny_remote.c:649: const char* one_t = getenv("HAKMEM_TINY_ASSUME_1T"); +core/tiny_route.h:33: const char* e = getenv("HAKMEM_ROUTE"); +core/tiny_route.h:41: const char* e = getenv("HAKMEM_ROUTE_SAMPLE_LG"); +core/tiny_superslab_alloc.inc.h:292: const char* e = getenv("HAKMEM_TINY_ALLOC_REMOTE_RELAX"); +core/tiny_superslab_free.inc.h:132: const char* e = getenv("HAKMEM_TINY_SLL_DIAG"); +core/tiny_superslab_free.inc.h:198: const char* e = getenv("HAKMEM_TINY_ROUTE_FREE"); +core/tiny_superslab_free.inc.h:209: const char* e = getenv("HAKMEM_TINY_FREE_TO_SS"); +core/tiny_superslab_free.inc.h:229: const char* e = getenv("HAKMEM_SS_FREE_DEBUG"); +core/tiny_superslab_free.inc.h:249: const char* e = getenv("HAKMEM_TINY_ROUTE_FREE"); +core/tiny_superslab_free.inc.h:266: const char* e = getenv("HAKMEM_SS_FREE_DEBUG"); +core/tiny_superslab_free.inc.h:359: char* e = getenv("HAKMEM_TINY_SS_ADOPT"); +core/tiny_superslab_free.inc.h:370: const char* e = getenv("HAKMEM_TINY_DISABLE_REMOTE"); +core/tiny_superslab_free.inc.h:435: const char* e = getenv("HAKMEM_TINY_FREELIST_MASK"); +core/tiny_superslab_free.inc.h:456: const char* e = getenv("HAKMEM_SS_FREE_DEBUG"); +core/ultra/tiny_ultra_heap.c:23: const char* e = getenv("HAKMEM_TINY_ULTRA_L0"); +core/ultra/tiny_ultra_heap.c:180: const char* dump = getenv("HAKMEM_TINY_ULTRA_HEAP_DUMP"); +core/ultra/tiny_ultra_page_arena.c:71: const char* dump = getenv("HAKMEM_TINY_ULTRA_PAGE_DUMP"); ``` - -**RESULT**: No cleanup needed - already removed! ✅ - ---- - -## Priority 2: Features Still Compiled But Possibly Unused - -These features exist as files and are compiled into binaries, but may be disabled by default or experimental: - -### 2A. SFC (Shared Frontend Cache) - ⚠️ **ACTIVE** (Default: ON) - -**Status**: ACTIVE and compiled into all binaries (hakmem_tiny_sfc.o) -**Default**: `g_sfc_enabled = 1` (ON by default!) -**Decision**: **KEEP** - This is an active optimization - -**ENV Variables** (6 vars): -``` -File: core/hakmem_tiny_sfc.c -- Line 51: getenv("HAKMEM_SFC_ENABLE") # A/B toggle -- Line 62: getenv("HAKMEM_SFC_CAPACITY") # Tuning -- Line 71: getenv("HAKMEM_SFC_REFILL_COUNT") # Tuning -- Line 123: getenv("HAKMEM_SFC_DEBUG") # Debug -- Line 144: getenv("HAKMEM_SFC_STATS_DUMP") # Stats - -File: core/tiny_alloc_fast.inc.h -- Line 477: getenv("HAKMEM_SFC_CASCADE_PCT") # Advanced tuning - -File: core/tiny_alloc_fast_sfc.inc.h -- Line 114: getenv("HAKMEM_SFC_DEBUG") # Debug (duplicate) - -File: core/tiny_free_fast.inc.h -- Line 104: getenv("HAKMEM_SFC_DEBUG") # Debug (duplicate) - -File: core/box/hak_wrappers.inc.h -- Line 89: getenv("HAKMEM_SFC_DEBUG") # Debug (duplicate) -``` - -**Action**: KEEP ALL (active feature) - ---- - -### 2B. BG (Background System) - ⚠️ **PARTIALLY ACTIVE** - -**Status**: Files exist, compiled in (hakmem_tiny_bg_spill.o, hakmem_batch.o) -**Default**: `g_bg_enabled = 1` in hakmem_batch.c -**Compiled**: YES (hakmem_batch.o, hakmem_tiny_bg_spill.o in OBJS_BASE) - -**ENV Variables** (5+ vars): -``` -File: core/hakmem_batch.c -- Line 73: getenv("HAKMEM_BATCH_BG") # Enable/disable - -File: core/hakmem_l25_pool.c (L25 BG drain) -- Line 741: getenv("HAKMEM_L25_BG_DRAIN") # L25 specific -- Line 743: getenv("HAKMEM_L25_BG_MS") # Interval - -File: core/hakmem_tiny_remote_target.c -- HAKMEM_TINY_BG_REMOTE (referenced in comments, no getenv found) -- HAKMEM_TINY_BG_REMOTE_BATCH (referenced in comments) -``` - -**Action**: VERIFY with user - if BG system is deprecated, can remove 5 vars - ---- - -### 2C. TC (Thread Cache for L25/MidPool) - ⚠️ **ACTIVE** - -**Status**: ACTIVE for Pool/L25 allocations -**Compiled**: YES (part of hakmem_l25_pool.o, mid_tcache.h) -**Default**: Enabled in some paths - -**ENV Variables** (10 vars): -``` -File: core/hakmem_l25_pool.c (L25 Pool TC) -- Line 737: getenv("HAKMEM_L25_TC_SPILL") # Spill threshold -- Line 739: getenv("HAKMEM_L25_TC_CAP") # TC capacity - -File: core/mid_tcache.h (Mid Pool TC) -- Line 16: getenv("HAKMEM_MID_TC") # Enable -- Line 25: getenv("HAKMEM_MID_TC_CAP") # Capacity - -File: core/box/pool_init_api.inc.h (Generic TC) -- Line 72: getenv("HAKMEM_TC_ENABLE") # Enable -- Line 74: getenv("HAKMEM_TC_UNBOUNDED") # Mode -- Line 76: getenv("HAKMEM_TC_DRAIN_MAX") # Drain max -- Line 78: getenv("HAKMEM_TC_DRAIN_TRIGGER") # Drain trigger - -File: core/hakmem_batch.c (Batch system) -- HAKMEM_DISABLE_BATCH (referenced, may relate to TC) -``` - -**Action**: KEEP - TC is active for Pool allocations - ---- - -### 2D. Ultra Features - ⚠️ **EXPERIMENTAL/GATED** - -**Status**: Files exist but ENV-gated (disabled by default) -**Compiled**: Files exist but likely inactive -**Default**: Disabled/experimental - -**ENV Variables** (8 vars): -``` -File: core/front/tiny_ultrafront.h -- getenv("HAKMEM_TINY_ULTRA_FRONT") # UltraFront variant - -File: core/ultra/tiny_ultra_heap.c -- getenv("HAKMEM_TINY_ULTRA_L0") # Ultra L0 layer -- getenv("HAKMEM_TINY_ULTRA_HEAP_DUMP") # Debug dump - -File: core/ultra/tiny_ultra_page_arena.c -- getenv("HAKMEM_TINY_ULTRA_PAGE_DUMP") # Debug dump - -File: core/box/ultra_slim_alloc_box.h -- getenv("HAKMEM_TINY_ULTRA_SLIM") # UltraSlim mode -- getenv("HAKMEM_ULTRA_SLIM_STATS") # Stats - -File: core/box/hak_core_init.inc.h -- getenv("HAKMEM_TINY_ULTRA_DEBUG") # Debug -``` - -**Action**: VERIFY - if Ultra features are experimental/unused, mark as deprecated - ---- - -### 2E. Frontend V2/Heap V2 - ⚠️ **POSSIBLY OBSOLETE** - -**Status**: ENV vars exist but feature may be replaced -**Compiled**: Part of frontend code - -**ENV Variables** (7 vars): -``` -File: core/front/tiny_heap_v2.h -- getenv("HAKMEM_TINY_HEAP_V2_CLASS_MASK") # Class mask -- getenv("HAKMEM_TINY_HEAP_V2_LEFTOVER_MODE") # Leftover mode -- getenv("HAKMEM_TINY_HEAP_V2_DEBUG") # Debug - -File: core/tiny_alloc_fast.inc.h -- getenv("HAKMEM_TINY_HEAP_V2_STATS") # Stats - -File: core/box/front_metrics_box.h -- getenv("HAKMEM_TINY_FRONT_DISABLE_HEAPV2") # Disable toggle - -File: core/tiny_alloc_fast.inc.h -- getenv("HAKMEM_TINY_FRONT_V2") # Front V2 enable -- getenv("HAKMEM_TINY_FRONT_SLIM") # Slim variant -- getenv("HAKMEM_TINY_FRONT_DIRECT") # Direct mode -- getenv("HAKMEM_TINY_FRONT_METRICS") # Metrics -- getenv("HAKMEM_TINY_FRONT_DUMP") # Dump -- getenv("HAKMEM_TINY_FRONT_ENABLE_ULTRAHOT") # UltraHot (obsolete?) -``` - -**Action**: VERIFY - Heap V2 status with user - ---- - -### 2F. Ring/SLL Features - ⚠️ **MIXED STATUS** - -**Status**: Some ring vars still in use (L25 TLS ring), others removed -**Compiled**: Mixed - -**ENV Variables** (6 vars): -``` -File: core/hakmem_l25_pool.c (ACTIVE - L25 TLS ring) -- Line 718: getenv("HAKMEM_POOL_TLS_RING") # ✅ ACTIVE -- Line 724: getenv("HAKMEM_RING_RETURN_DIV") # ✅ ACTIVE -- Line 745: getenv("HAKMEM_L25_RING_TRIGGER") # ✅ ACTIVE - -File: core/box/pool_init_api.inc.h (ACTIVE) -- getenv("HAKMEM_POOL_TLS_RING") # ✅ ACTIVE (duplicate) -- getenv("HAKMEM_RING_RETURN_DIV") # ✅ ACTIVE (duplicate) - -File: core/box/tls_sll_box.h (SLL ring - may be different) -- Line 115: getenv("HAKMEM_TINY_SLL_RING") # SLL variant ring - -File: core/tiny_debug_ring.c (Debug ring) -- getenv("HAKMEM_TINY_TRACE_RING") # Debug trace -- getenv("HAKMEM_TINY_DUMP_RING_ATEXIT") # Dump at exit -``` - -**Action**: -- KEEP: HAKMEM_POOL_TLS_RING, HAKMEM_RING_RETURN_DIV, HAKMEM_L25_RING_TRIGGER (L25 active) -- VERIFY: HAKMEM_TINY_SLL_RING, HAKMEM_TINY_TRACE_RING, HAKMEM_TINY_DUMP_RING_ATEXIT - ---- - -### 2G. HotMag / SmallMag - ⚠️ **FILE EXISTS, STATUS UNCLEAR** - -**Status**: File exists (core/hakmem_tiny_hotmag.inc.h) but no active ENV refs -**Compiled**: Likely included but no dedicated .o file - -**ENV Variables** (1 var): -``` -File: core/hakmem_tiny_smallmag.inc.h -- getenv("HAKMEM_TINY_SMALL_MAG") # Enable SmallMag -``` - -**Action**: VERIFY - check if HotMag/SmallMag are used or obsolete - ---- - -### 2H. BigCache - ✅ **ACTIVE** - -**Status**: ACTIVE and compiled (hakmem_bigcache.o) -**Compiled**: YES (hakmem_bigcache.o in OBJS_BASE) - -**ENV Variables** (1 var): -``` -File: core/box/hak_free_api.inc.h -- getenv("HAKMEM_BIGCACHE_L25") # Enable BigCache for L25 -``` - -**Action**: KEEP - BigCache is active - ---- - -## Priority 3: Verification Needed - -These ENV variables need user/maintainer input: - -### 3A. Experimental Features (Gated by ENV, Default OFF) - -**Need decision**: Keep for experiments or remove? - -``` -HAKMEM_TINY_ULTRA_FRONT # UltraFront experiment -HAKMEM_TINY_ULTRA_L0 # Ultra L0 layer -HAKMEM_TINY_ULTRA_SLIM # UltraSlim mode -HAKMEM_TINY_HEAP_V2_* # Heap V2 features (4 vars) -HAKMEM_TINY_FRONT_V2 # Frontend V2 -HAKMEM_TINY_FRONT_SLIM # Frontend Slim -HAKMEM_TINY_FRONT_ENABLE_ULTRAHOT # UltraHot toggle (feature removed!) -``` - -### 3B. Debug/Stats Variables - -**Keep for debugging or remove?** - -``` -HAKMEM_SFC_DEBUG # SFC debug (4 duplicate locations!) -HAKMEM_TINY_ULTRA_DEBUG # Ultra debug -HAKMEM_TINY_ULTRA_HEAP_DUMP # Ultra heap dump -HAKMEM_TINY_ULTRA_PAGE_DUMP # Ultra page dump -HAKMEM_ULTRA_SLIM_STATS # UltraSlim stats -HAKMEM_TINY_HEAP_V2_DEBUG # Heap V2 debug -HAKMEM_TINY_FRONT_METRICS # Front metrics -HAKMEM_TINY_FRONT_DUMP # Front dump -HAKMEM_TINY_TRACE_RING # Debug ring trace -HAKMEM_TINY_DUMP_RING_ATEXIT # Dump ring at exit -``` - ---- - -## Execution Plan - -### Phase 1: Remove Duplicate/Dead Code (Immediate) - -**NO ACTION NEEDED** - Already cleaned in bcfb4f6b5 and 225b6fcc7 ✅ - -### Phase 2: Consolidate Duplicate Debug Checks (Low Risk) - -**File**: core/tiny_alloc_fast_sfc.inc.h, core/tiny_free_fast.inc.h, core/box/hak_wrappers.inc.h - -**Problem**: `getenv("HAKMEM_SFC_DEBUG")` called 4 times in different files - -**Fix**: Create single global `g_sfc_debug` variable, set once in `sfc_init()` - -**Lines to modify**: -- core/hakmem_tiny_sfc.c:123 - Keep this one (in init) -- core/tiny_alloc_fast_sfc.inc.h:114 - Change to `extern int g_sfc_debug` -- core/tiny_free_fast.inc.h:104 - Change to `extern int g_sfc_debug` -- core/box/hak_wrappers.inc.h:89 - Change to `extern int g_sfc_debug` - -**Impact**: Reduces 3 getenv() calls per debug check to 1 at init - -### Phase 3: Verify Experimental Features (Needs Input) - -**Questions for user/maintainer**: - -1. **Ultra features** - Are these experiments still active? - - HAKMEM_TINY_ULTRA_FRONT - - HAKMEM_TINY_ULTRA_L0 - - HAKMEM_TINY_ULTRA_SLIM - - HAKMEM_ULTRA_SLIM_STATS - -2. **Heap V2** - Is this still used or replaced? - - HAKMEM_TINY_HEAP_V2_* (4 vars) - -3. **Frontend variants** - Which are active? - - HAKMEM_TINY_FRONT_V2 - - HAKMEM_TINY_FRONT_SLIM - - HAKMEM_TINY_FRONT_ENABLE_ULTRAHOT (should remove - UltraHot deleted!) - -4. **BG system** - Still needed? - - HAKMEM_BATCH_BG - - HAKMEM_L25_BG_DRAIN - - HAKMEM_L25_BG_MS - -5. **HotMag/SmallMag** - Used or obsolete? - - HAKMEM_TINY_SMALL_MAG - -### Phase 4: Mark Deprecated (If Removing) - -Add to documentation: -``` -## Deprecated ENV Variables (Removed in vX.X) - -The following ENV variables are deprecated and no longer have any effect: -- HAKMEM_TINY_FRONT_ENABLE_ULTRAHOT (feature removed in bcfb4f6b5) -- [Add others after verification] -``` - ---- - -## Summary Table - -| Category | Total Vars | Status | Action | -|----------|------------|--------|--------| -| Already Removed | 11 | ✅ Clean | None | -| SFC (Active) | 6 | ✅ Keep | Deduplicate debug | -| BG System | 5 | ⚠️ Verify | Need input | -| TC (Thread Cache) | 10 | ✅ Keep | None | -| Ultra Features | 8 | ⚠️ Verify | Need input | -| Heap V2 | 7 | ⚠️ Verify | Need input | -| Ring/SLL | 6 | 🟡 Mixed | Keep L25, verify Tiny | -| HotMag/SmallMag | 1 | ⚠️ Verify | Need input | -| BigCache | 1 | ✅ Keep | None | -| **TOTAL** | **55** | | | - ---- - -## Next Steps - -1. **User decision needed**: Verify experimental features (Phase 3 questions) -2. **Quick win**: Deduplicate SFC_DEBUG checks (Phase 2) -3. **Documentation**: Mark deprecated vars -4. **Testing**: Ensure no ENV var removal breaks existing users -5. **Gradual removal**: Deprecate → warn → remove (3-release cycle) - ---- - -## Files Requiring Modification - -### Immediate Changes (Phase 2 - SFC Debug Deduplication): -- core/hakmem_tiny_sfc.c (add global) -- core/tiny_alloc_fast_sfc.inc.h (change to extern) -- core/tiny_free_fast.inc.h (change to extern) -- core/box/hak_wrappers.inc.h (change to extern) - -### Pending Verification (Phase 3): -- core/front/tiny_ultrafront.h -- core/front/tiny_heap_v2.h -- core/ultra/tiny_ultra_heap.c -- core/ultra/tiny_ultra_page_arena.c -- core/box/ultra_slim_alloc_box.h -- core/hakmem_batch.c -- core/hakmem_l25_pool.c -- core/hakmem_tiny_smallmag.inc.h -- core/tiny_alloc_fast.inc.h -- core/box/front_metrics_box.h - -**Total files**: ~14 files need review/modification - ---- - -## Risk Assessment - -- **Phase 1**: ✅ Zero risk (already done) -- **Phase 2**: 🟢 Low risk (internal optimization, no behavior change) -- **Phase 3**: 🟡 Medium risk (need verification, user-facing) -- **Phase 4**: 🔴 High risk (breaking change, needs deprecation cycle) - -**Recommendation**: Start with Phase 2 (safe), then get user input for Phase 3. diff --git a/docs/analysis/ENV_CLEANUP_SUMMARY.md b/docs/analysis/ENV_CLEANUP_SUMMARY.md index a08c2cad..cf8f2300 100644 --- a/docs/analysis/ENV_CLEANUP_SUMMARY.md +++ b/docs/analysis/ENV_CLEANUP_SUMMARY.md @@ -1,92 +1,33 @@ # ENV Variable Cleanup Analysis - Executive Summary +## Scope + +- **Initial sweep:** 221 unique ENV variables across the runtime (getenv()). +- **Current view:** Core features Ultra/BG/HeapV2 are active and must be preserved (A/B gated only). +- **Docs-only cleanup:** 21 documentation-only variables (zero getenv hits) are tracked separately in `SAFE_TO_DELETE_ENV_VARS.md`. + ## Key Findings -### Good News: Most "Obsolete" Features Already Cleaned! ✅ +- **Active, keep**: Ultra path (`core/ultra/*`), BG spill (`hakmem_batch.c`, `hakmem_tiny_bg_spill.o`), HeapV2/FrontV2 (`core/front/tiny_heap_v2.h`, `tiny_alloc_fast.inc.h`) are compiled in and runtime-gated. Removing their ENV toggles would break A/B rollback. +- **SFC is live**: `hakmem_tiny_sfc.o` is built; `HAKMEM_SFC_ENABLE/CAPACITY/REFILL_COUNT/DEBUG/STATS_DUMP/CASCADE_PCT` all drive behavior. Debug getenv duplication remains the top low-risk cleanup. +- **Doc-only set**: 21 proposal-only ENV names (adaptive presets, generic debug knobs, legacy build flags) have no getenv calls; safe to drop from docs with zero runtime impact. +- **Count drift**: Including `.inc` helpers raises the current getenv surface to ~279 names; initial 221 figure is kept as the baseline for this project’s first pass. -The major obsolete features (UltraHot, RingCache, FrontC23, Class5) were **already removed** in commits: -- bcfb4f6b5: "Remove dead code: UltraHot, RingCache, FrontC23, Class5 Hotpath" -- 225b6fcc7: Duplicate cleanup commit -- a9ddb52ad: "ENV cleanup: Remove BG/HotMag vars" +## Quick Wins (low risk, Box-friendly) -All 11 ENV variables for these features are **already gone from the codebase** ✅ +- **SFC_DEBUG dedup**: Move the four `HAKMEM_SFC_DEBUG` getenv calls behind one init-time flag (`hakmem_tiny_sfc.c` as the boundary). Reduces hot-path getenvs by 3. +- **Doc hygiene**: Remove the 21 docs-only names from `docs/specs/ENV_VARS*.md` to keep the supported surface visible and reversible. -### Surprise Finding: SFC is ACTIVE (Not Obsolete!) +## Items to Keep as-is (cannot delete) -**SFC (Shared Frontend Cache)** was listed as "obsolete" but analysis shows: -- ✅ Compiled in all binaries (hakmem_tiny_sfc.o) -- ✅ Default: `g_sfc_enabled = 1` (ON by default) -- ✅ Active optimization with 6 ENV vars -- **Action**: KEEP all SFC vars +- **Ultra toggles**: `HAKMEM_TINY_ULTRA_*`, `HAKMEM_ULTRA_SLIM_STATS` — gated experiments but compiled; keep for rollback. +- **BG system**: `HAKMEM_BATCH_BG`, `HAKMEM_L25_BG_DRAIN`, `HAKMEM_L25_BG_MS` — enabled by default; removal would change behavior. +- **HeapV2/FrontV2**: `HAKMEM_TINY_HEAP_V2_*`, `HAKMEM_TINY_FRONT_V2/SLIM/DIRECT/METRICS/DUMP` — active path for tiny frontend; keep. -### Actual Cleanup Opportunities +## Next Steps -**54 potentially obsolete vars** break down as: -- 11 vars: Already removed ✅ -- 16 vars: Active features (SFC, TC, BigCache) - KEEP ✅ -- 6 vars: Active L25 TLS ring - KEEP ✅ -- **21 vars: Need verification** ⚠️ +1) Implement `HAKMEM_SFC_DEBUG` consolidation (init boundary only). +2) Sweep docs to drop the 21 docs-only variables (no code changes). +3) Maintain A/B gates for Ultra/BG/HeapV2; any deprecation must be feature-flagged with rollback. -## Priority 1: Quick Wins (No Risk) - -### SFC Debug Deduplication -**Problem**: `getenv("HAKMEM_SFC_DEBUG")` called 4x in different files -**Fix**: Single global variable, set once at init -**Savings**: -3 getenv() calls per debug check -**Risk**: Zero -**Files**: 4 files, ~8 lines total - -## Priority 2: Verification Needed (21 vars) - -| Feature | Vars | Status | Question | -|---------|------|--------|----------| -| Ultra features | 8 | Gated/experimental | Still needed? | -| Heap V2 | 7 | Unknown | Active or replaced? | -| BG System | 5 | Partially active | Keep or deprecate? | -| HotMag/SmallMag | 1 | File exists | Used or obsolete? | - -## Priority 3: Deprecation Candidates - -**IF verification confirms obsolete** (needs user input): - -``` -HAKMEM_TINY_FRONT_ENABLE_ULTRAHOT # UltraHot removed in bcfb4f6b5! -HAKMEM_TINY_ULTRA_* (if unused) # 8 vars -HAKMEM_TINY_HEAP_V2_* (if replaced) # 7 vars -HAKMEM_BATCH_BG (if deprecated) # 5 vars -``` - -**Total potential**: Up to 21 vars (after verification) - -## Recommended Action Plan - -### Immediate (This Week) -1. ✅ Deduplicate SFC_DEBUG (4 files, low risk) -2. ✅ Remove HAKMEM_TINY_FRONT_ENABLE_ULTRAHOT (UltraHot deleted!) - -### Short Term (Next Sprint) -3. ⚠️ Verify Ultra features with maintainers -4. ⚠️ Verify Heap V2 status -5. ⚠️ Verify BG system usage -6. ⚠️ Verify HotMag/SmallMag - -### Long Term (Next Release) -7. 📝 Mark deprecated vars in documentation -8. 🔔 Add runtime warnings for deprecated vars -9. 🗑️ Remove after deprecation cycle (3 releases) - -## Impact Assessment - -**Current state**: 221 ENV vars -**Safe to remove now**: 1 var (ULTRAHOT toggle) -**After verification**: Up to 21 vars (if all experimental features unused) -**Best case reduction**: ~10% (-22 vars) - -## Detailed Plan - -See `ENV_CLEANUP_PLAN.md` for: -- File-by-file breakdown -- Line numbers for all getenv() calls -- Priority ordering -- Risk assessment -- Verification questions +See `ENV_CLEANUP_PLAN.md` for the full getenv map (file+line) and `ENV_CONSOLIDATION_PLAN.md` for the long-term policy reduction (149 → ~30). diff --git a/docs/analysis/ENV_CONSOLIDATION_PLAN.md b/docs/analysis/ENV_CONSOLIDATION_PLAN.md index b7f24f26..a4f39b78 100644 --- a/docs/analysis/ENV_CONSOLIDATION_PLAN.md +++ b/docs/analysis/ENV_CONSOLIDATION_PLAN.md @@ -1,369 +1,28 @@ -# HAKMEM ENV Variable Consolidation - Detailed Mapping +# ENV Consolidation Plan (149 policy vars → ~30) -## OBSOLETE Variables - Complete List (54 vars) +## Summary +- Current surface: ~279 getenv-based ENV names; policy/tuning bucket accounts for **~149** of them. +- Guardrails: **Ultra**, **BG**, **HeapV2/FrontV2**, **SFC**, **TC/Ring** stay; consolidation must not remove A/B rollback paths. +- Goal: converge on **30 policy knobs** (plus ~20 essentials) by merging duplicate/refined knobs and moving getenv to init-time Box boundaries. +- Docs-only debris: 21 proposal-only names are tracked separately in `SAFE_TO_DELETE_ENV_VARS.md` and can be pruned from docs. -### BG (Background) System - 11 vars -``` -HAKMEM_BATCH_BG -HAKMEM_L25_BG_DRAIN -HAKMEM_L25_BG_MS -``` +## What Stays (no consolidation/removal) +- **Essential (runtime-required)**: `HAKMEM_WRAP_TINY`, `HAKMEM_TINY_USE_SUPERSLAB`, `HAKMEM_TINY_TLS_SLL`, `HAKMEM_TINY_FREE_FAST`, `HAKMEM_TINY_UNIFIED_CACHE`, `HAKMEM_SS_EMPTY_REUSE`, `HAKMEM_FRONT_GATE_UNIFIED`, `HAKMEM_POOL_TLS_FREE`, page arena knobs, prewarm knobs, and SmallMid enable. +- **Active feature flags**: Ultra (`HAKMEM_TINY_ULTRA_*`, `HAKMEM_ULTRA_SLIM_STATS`), BG (`HAKMEM_BATCH_BG`, `HAKMEM_L25_BG_*`), HeapV2/FrontV2 (`HAKMEM_TINY_HEAP_V2_*`, `HAKMEM_TINY_FRONT_*`), SFC (`HAKMEM_SFC_*`), TC/Ring (`HAKMEM_TC_*`, `HAKMEM_POOL_TLS_RING`, `HAKMEM_RING_RETURN_DIV`, `HAKMEM_L25_RING_TRIGGER`). +- **Debug knobs**: Keep but gate behind init-time caches or build flags (no repeated getenv in hot paths). -### SFC (Shared Frontend Cache) - 7 vars -``` -HAKMEM_SFC_CAPACITY -HAKMEM_SFC_CASCADE_PCT -HAKMEM_SFC_DEBUG -HAKMEM_SFC_ENABLE -HAKMEM_SFC_REFILL_COUNT -HAKMEM_SFC_STATS_DUMP -HAKMEM_TINY_SFC_CASCADE -``` +## Consolidation Targets (149 → ~30) +- **Refill parameters**: 18 knobs → 3 (`HAKMEM_REFILL_BATCH`, `HAKMEM_REFILL_HOT_BATCH`, `HAKMEM_REFILL_MAX`). +- **Capacity presets**: 25 knobs → 6 (`HAKMEM_CACHE_PRESET`, `HAKMEM_TINY_CACHE_SLOTS`, `HAKMEM_MID_CACHE_SLOTS`, `HAKMEM_LARGE_CACHE_SLOTS`, `HAKMEM_SS_MEMORY_LIMIT_MB`, `HAKMEM_POOL_MEMORY_LIMIT_MB`). +- **Adaptive/learning**: 35 knobs → 8 (`HAKMEM_ADAPTIVE_MODE`, `HAKMEM_ADAPTIVE_TARGETS`, `HAKMEM_ADAPTIVE_INTERVAL_MS`, `HAKMEM_ADAPTIVE_AGGRESSIVENESS`, `HAKMEM_ADAPTIVE_MIN_CHANGE_PCT`, `HAKMEM_THP_POLICY`, `HAKMEM_WMAX_MID_KB`, `HAKMEM_WMAX_LARGE_KB`). +- **Drain/thresholds**: 20 knobs → 5 (`HAKMEM_REMOTE_DRAIN_THRESHOLD`, `HAKMEM_REMOTE_DRAIN_BATCH`, `HAKMEM_CACHE_SPILL_PCT`, `HAKMEM_MEMORY_TRIM_INTERVAL_MS`, `HAKMEM_IDLE_TIMEOUT_MS`). +- **L25/Pool tuning**: 15 knobs → 5 (`HAKMEM_L25_SIZE_ZONES`, `HAKMEM_L25_BUNDLE_SIZE`, `HAKMEM_MID_BUNDLE_SIZE`, `HAKMEM_L25_RUN_BLOCKS`, `HAKMEM_L25_RUN_FACTOR`). +- **Global presets**: 36 knobs → 3 (`HAKMEM_MODE`, `HAKMEM_FORCE_LIBC`, `HAKMEM_RSS_BUDGET_KB`). -### HotMag/Ultra/Quick Caches - 12 vars -``` -HAKMEM_TINY_FRONT_ENABLE_ULTRAHOT -HAKMEM_TINY_QUICK -HAKMEM_TINY_ULTRA -HAKMEM_TINY_ULTRA_DEBUG -HAKMEM_TINY_ULTRA_FRONT -HAKMEM_TINY_ULTRA_HEAP_DUMP -HAKMEM_TINY_ULTRA_L0 -HAKMEM_TINY_ULTRA_PAGE_DUMP -HAKMEM_TINY_ULTRA_SIMPLE -HAKMEM_TINY_ULTRA_SLIM -HAKMEM_TINY_ULTRA_VALIDATE -HAKMEM_ULTRA_SLIM_STATS -``` +## Proposed End-State Variables -### Ring System - 7 vars +**Essential (keep as-is, ~20)** ``` -HAKMEM_L25_RING_TRIGGER -HAKMEM_POOL_TLS_RING -HAKMEM_RING_RETURN_DIV -HAKMEM_TINY_ALLOC_RING -HAKMEM_TINY_DUMP_RING_ATEXIT -HAKMEM_TINY_SLL_RING -HAKMEM_TINY_TRACE_RING -``` - -### Thread Cache (TC) - 4 vars -``` -``` - -### BigCache/L25 Experiments - 7 vars -``` -HAKMEM_BIGCACHE_L25 -HAKMEM_DISABLE_BIGCACHE -HAKMEM_L25_BG_DRAIN -HAKMEM_L25_BG_MS -HAKMEM_L25_RING_TRIGGER -HAKMEM_L25_TC_CAP -HAKMEM_L25_TC_SPILL -``` - -### Frontend Experiments - 13 vars -``` -HAKMEM_TINY_FASTCACHE -HAKMEM_TINY_FRONTEND -HAKMEM_TINY_FRONT_DISABLE_HEAPV2 -HAKMEM_TINY_FRONT_ENABLE_ULTRAHOT -HAKMEM_TINY_FRONT_SLIM -HAKMEM_TINY_FRONT_V2 -HAKMEM_TINY_HEAP_V2_CLASS_MASK -HAKMEM_TINY_HEAP_V2_DEBUG -HAKMEM_TINY_HEAP_V2_LEFTOVER_MODE -HAKMEM_TINY_HEAP_V2_STATS -``` - ---- - -## DEBUG Variables - Complete List (59 vars) - -### Tracing - 16 vars -``` -HAKMEM_FREE_ROUTE_TRACE -HAKMEM_FREE_WRAP_TRACE -HAKMEM_PTR_TRACE_DUMP -HAKMEM_PTR_TRACE_VERBOSE -HAKMEM_SUPER_REG_REQTRACE -HAKMEM_TINY_MAILBOX_TRACE -HAKMEM_TINY_MAILBOX_TRACE_LIMIT -HAKMEM_TINY_RF_TRACE -HAKMEM_TINY_SUPERSLAB_TRACE -HAKMEM_TINY_TRACE_RING -``` - -### Logging - 8 vars -``` -HAKMEM_ADAPTIVE_LOG -HAKMEM_EXTERNAL_GUARD_LOG -HAKMEM_INVALID_FREE_LOG -HAKMEM_LOG_FILE -HAKMEM_PTR_TRACE_VERBOSE -HAKMEM_VERBOSE -``` - -### Stats/Profiling - 16 vars -``` -HAKMEM_EXTERNAL_GUARD_STATS -HAKMEM_POOL_COUNT_SAMPLE -HAKMEM_PROF_SAMPLE -HAKMEM_SFC_STATS_DUMP -HAKMEM_SHARED_POOL_LOCK_STATS -HAKMEM_SHARED_POOL_STAGE_STATS -HAKMEM_TINY_ALLOC_1024_METRIC -HAKMEM_TINY_COUNT_SAMPLE -HAKMEM_TINY_FAST_STATS -HAKMEM_TINY_FRONT_METRICS -HAKMEM_TINY_HEAP_V2_STATS -HAKMEM_ULTRA_SLIM_STATS -``` - -### Debug/Observe - 19 vars -``` -HAKMEM_ACE_DEBUG -HAKMEM_ACE_OBSERVE -HAKMEM_DEBUG_SEGV -HAKMEM_PTR_TRACE_DUMP -HAKMEM_SFC_DEBUG -HAKMEM_SFC_STATS_DUMP -HAKMEM_SS_ACQUIRE_DEBUG -HAKMEM_SS_FREE_DEBUG -HAKMEM_SS_LRU_DEBUG -HAKMEM_SS_PREWARM_DEBUG -HAKMEM_SUPER_LOOKUP_DEBUG -HAKMEM_SUPER_REG_DEBUG -HAKMEM_TINY_ALLOC_DEBUG -HAKMEM_TINY_COUNTERS_DUMP -HAKMEM_TINY_DEBUG_FAST0 -HAKMEM_TINY_DEBUG_REMOTE_GUARD -HAKMEM_TINY_DUMP_ATEXIT_ONLY -HAKMEM_TINY_DUMP_RING_ATEXIT -HAKMEM_TINY_FAST_DEBUG -HAKMEM_TINY_FAST_DEBUG_MAX -``` - ---- - -## POLICY Variables - Consolidation Proposals - -### Proposal 1: Refill Parameters - -**Remove (18 vars)**: -``` -HAKMEM_INT_ADAPT_REFILL -HAKMEM_SFC_REFILL_COUNT -HAKMEM_TINY_MID_REFILL_SIMPLE -HAKMEM_TINY_REFILL_COUNT -HAKMEM_TINY_REFILL_COUNT_HOT -HAKMEM_TINY_REFILL_COUNT_MID -HAKMEM_TINY_REFILL_DUMP -HAKMEM_TINY_REFILL_FAILFAST -HAKMEM_TINY_REFILL_MAX -HAKMEM_TINY_REFILL_MAX_HOT -HAKMEM_TINY_REFILL_ONE_ON_MISS -HAKMEM_TINY_REFILL_OPT_DEBUG -HAKMEM_WRAP_TINY_REFILL -``` - -**Replace with (3 vars)**: -``` -HAKMEM_REFILL_BATCH=64 # Default refill batch size -HAKMEM_REFILL_HOT_BATCH=192 # Hot class (C0-C3) batch size -HAKMEM_REFILL_MAX=1024 # Maximum refill per operation -``` - -### Proposal 2: Capacity Limits - -**Remove (30+ vars including per-class)**: -``` -HAKMEM_CAP_LARGE -HAKMEM_CAP_MID -HAKMEM_CAP_MID_DYN1 -HAKMEM_CAP_MID_DYN2 -HAKMEM_L25_MIN_BUNDLE -HAKMEM_MF2_MAX_QUEUES -HAKMEM_POOL_MIN_BUNDLE -HAKMEM_SUPERSLAB_MAX_CACHED -HAKMEM_SUPERSLAB_MAX_MEMORY_MB -HAKMEM_TINY_MAG_CAP -HAKMEM_TINY_MAX_CLASS -HAKMEM_TINY_REFILL_MAX_HOT -HAKMEM_TINY_SS_MAX_MB -HAKMEM_TINY_SS_MIN_MB -...(30+ total) -``` - -**Replace with (6 vars)**: -``` -HAKMEM_CACHE_PRESET=small|medium|large|custom # Global preset -HAKMEM_TINY_CACHE_SLOTS=512 # TLS cache capacity (if custom) -HAKMEM_MID_CACHE_SLOTS=128 # Mid-tier cache (if custom) -HAKMEM_LARGE_CACHE_SLOTS=32 # Large-tier cache (if custom) -HAKMEM_SS_MEMORY_LIMIT_MB=512 # SuperSlab memory cap -HAKMEM_POOL_MEMORY_LIMIT_MB=256 # Pool memory cap -``` - -**Presets**: -``` -small: Tiny=256, Mid=64, Large=16, SS=256MB, Pool=128MB -medium: Tiny=512, Mid=128, Large=32, SS=512MB, Pool=256MB (default) -large: Tiny=1024, Mid=256, Large=64, SS=1024MB, Pool=512MB -custom: Use individual *_SLOTS/*_LIMIT_MB vars -``` - -### Proposal 3: Learning/Adaptation Systems - -**Remove (35 vars)**: -``` -HAKMEM_ACE_DEBUG -HAKMEM_ACE_ENABLED -HAKMEM_ACE_OBSERVE -HAKMEM_ACE_PROFILE -HAKMEM_ACE_SAMPLE -HAKMEM_ADAPTIVE_LOG -HAKMEM_ADAPTIVE_SIZING -HAKMEM_CAP_MID_DYN1 -HAKMEM_CAP_MID_DYN2 -HAKMEM_DISABLE_ELO -HAKMEM_DYN1_AUTO -HAKMEM_DYN2_AUTO -HAKMEM_HOT_SLOT -HAKMEM_INT_ADAPT_CAPS -HAKMEM_INT_ADAPT_REFILL -HAKMEM_INT_ENGINE -HAKMEM_INT_EVENT_TS -HAKMEM_INT_SAMPLE -HAKMEM_LEARN -HAKMEM_LEARN_SAMPLE -HAKMEM_MID_DYN1 -HAKMEM_MID_DYN2 -HAKMEM_PTR_TRACE_DUMP -HAKMEM_PTR_TRACE_VERBOSE -HAKMEM_THP_LEARN -...(35 total) -``` - -**Replace with (8 vars)**: -``` -HAKMEM_ADAPTIVE_MODE=off|observe|active # Master switch -HAKMEM_ADAPTIVE_TARGETS=caps,refill,wmax,thp # Comma-separated targets -HAKMEM_ADAPTIVE_INTERVAL_MS=1000 # Update interval -HAKMEM_ADAPTIVE_AGGRESSIVENESS=0.1 # Learning rate (0.0-1.0) -HAKMEM_ADAPTIVE_MIN_CHANGE_PCT=5 # Minimum % change to apply -HAKMEM_THP_POLICY=off|auto|on # THP policy -HAKMEM_WMAX_MID_KB=256 # Mid-tier working set -HAKMEM_WMAX_LARGE_KB=2048 # Large-tier working set -``` - -### Proposal 4: Drain/Threshold Parameters - -**Remove (20 vars)**: -``` -HAKMEM_L25_BG_DRAIN -HAKMEM_L25_RING_TRIGGER -HAKMEM_MF2_IDLE_THRESHOLD_US -HAKMEM_TC_DRAIN_MAX -HAKMEM_TC_DRAIN_TRIGGER -HAKMEM_TINY_DRAIN_TO_SLL -HAKMEM_TINY_REMOTE_DRAIN_THRESHOLD -HAKMEM_TINY_REMOTE_DRAIN_TRYRATE -HAKMEM_TINY_SLL_DRAIN_DEBUG -HAKMEM_TINY_SLL_DRAIN_ENABLE -HAKMEM_TINY_SLL_DRAIN_INTERVAL -HAKMEM_TINY_TENSION_DRAIN_ENABLE -HAKMEM_TINY_TENSION_DRAIN_THRESHOLD -``` - -**Replace with (5 vars)**: -``` -HAKMEM_REMOTE_DRAIN_THRESHOLD=32 # Queue size to trigger drain -HAKMEM_REMOTE_DRAIN_BATCH=16 # Items per drain operation -HAKMEM_CACHE_SPILL_PCT=90 # % full to trigger spill -HAKMEM_MEMORY_TRIM_INTERVAL_MS=1000 # Trim check interval -HAKMEM_IDLE_TIMEOUT_MS=5000 # Idle detection timeout -``` - -### Proposal 5: L25/Pool Configuration - -**Remove (15 vars)**: -``` -HAKMEM_L25_DZ -HAKMEM_L25_INBOUND_SLOTS -HAKMEM_L25_MIN_BUNDLE -HAKMEM_L25_OWNER_INBOUND -HAKMEM_L25_PREF -HAKMEM_L25_REMOTE_SAFE -HAKMEM_L25_RUN_BLOCKS -HAKMEM_L25_RUN_FACTOR -HAKMEM_MID_TC -HAKMEM_POOL_MIN_BUNDLE -HAKMEM_SHARED_POOL_LOCK_STATS -HAKMEM_SHARED_POOL_STAGE_STATS -``` - -**Replace with (5 vars)**: -``` -HAKMEM_L25_SIZE_ZONES="64,256,1024" # Comma-separated size zones -HAKMEM_L25_BUNDLE_SIZE=4 # Refill bundle size -HAKMEM_MID_BUNDLE_SIZE=4 # Mid-tier bundle size -HAKMEM_L25_RUN_BLOCKS=16 # Blocks per run -HAKMEM_L25_RUN_FACTOR=2 # Run factor multiplier -``` - -### Proposal 6: Misc Policy Variables - -**Remove (36 vars)**: -``` -HAKMEM_ACE_ENABLED -HAKMEM_ALLOW_MALLOC_FALLBACK -HAKMEM_BENCH_FAST_FRONT -HAKMEM_BENCH_FAST_MODE -HAKMEM_BENCH_TINY_ONLY -HAKMEM_BIGCACHE_L25 -HAKMEM_DISABLE_BATCH -HAKMEM_DISABLE_BIGCACHE -HAKMEM_DISABLE_ELO -HAKMEM_EXTERNAL_GUARD_LOG -HAKMEM_EXTERNAL_GUARD_MINCORE -HAKMEM_EXTERNAL_GUARD_STATS -HAKMEM_FREE_POLICY -HAKMEM_FREE_ROUTE_TRACE -HAKMEM_HDR_LIGHT -HAKMEM_INVALID_FREE -HAKMEM_INVALID_FREE_LOG -HAKMEM_L25_REMOTE_SAFE -HAKMEM_L25_TC_SPILL -HAKMEM_LD_BLOCK_JEMALLOC -HAKMEM_LD_SAFE -HAKMEM_MF2_ENABLE -HAKMEM_MF2_IDLE_THRESHOLD_US -HAKMEM_MF2_LEASE_MS -HAKMEM_MF2_MAX_QUEUES -HAKMEM_MODE -HAKMEM_PAGE_ARENA_ENABLE -HAKMEM_PRESET -HAKMEM_ROUTE -HAKMEM_ROUTE_SAMPLE_LG -...(36 total) -``` - -**Replace with (4 vars)**: -``` -HAKMEM_MODE=fast|balanced|learning|minimal # High-level preset -HAKMEM_FORCE_LIBC=0|1 # Force libc malloc fallback -HAKMEM_THP_POLICY=off|auto|on # THP policy (from Proposal 3) -HAKMEM_RSS_BUDGET_KB=unlimited # Total RSS budget -``` - ---- - -## Final 50 Variables (20 Essential + 30 Policy) - -### Essential (20 vars) -``` -# Core Features (8) HAKMEM_WRAP_TINY=1 HAKMEM_TINY_USE_SUPERSLAB=1 HAKMEM_TINY_TLS_SLL=1 @@ -372,27 +31,21 @@ HAKMEM_TINY_UNIFIED_CACHE=1 HAKMEM_SS_EMPTY_REUSE=1 HAKMEM_FRONT_GATE_UNIFIED=1 HAKMEM_POOL_TLS_FREE=1 - -# Pool TLS Arena (3) HAKMEM_POOL_TLS_ARENA_MB_INIT=1 HAKMEM_POOL_TLS_ARENA_MB_MAX=8 HAKMEM_POOL_TLS_ARENA_GROWTH_LEVELS=3 - -# Page Arena (5) HAKMEM_PAGE_ARENA_ENABLE=1 HAKMEM_PAGE_ARENA_HOT_SIZE=... HAKMEM_PAGE_ARENA_WARM_64K=... HAKMEM_PAGE_ARENA_WARM_128K=... HAKMEM_PAGE_ARENA_WARM_2M=... - -# Misc (4) HAKMEM_PREWARM_SUPERSLABS=1 HAKMEM_TINY_PREWARM_ALL=1 HAKMEM_WRAP_TINY_REFILL=1 HAKMEM_SMALLMID_ENABLE=1 ``` -### Policy (30 vars) +**Policy (~30 total)** ``` # Refill (3) HAKMEM_REFILL_BATCH=64 @@ -408,12 +61,12 @@ HAKMEM_SS_MEMORY_LIMIT_MB=512 HAKMEM_POOL_MEMORY_LIMIT_MB=256 # Adaptive (8) -HAKMEM_ADAPTIVE_MODE=off +HAKMEM_ADAPTIVE_MODE=off|observe|active HAKMEM_ADAPTIVE_TARGETS=caps,refill,wmax HAKMEM_ADAPTIVE_INTERVAL_MS=1000 HAKMEM_ADAPTIVE_AGGRESSIVENESS=0.1 HAKMEM_ADAPTIVE_MIN_CHANGE_PCT=5 -HAKMEM_THP_POLICY=auto +HAKMEM_THP_POLICY=off|auto|on HAKMEM_WMAX_MID_KB=256 HAKMEM_WMAX_LARGE_KB=2048 @@ -432,65 +85,75 @@ HAKMEM_L25_RUN_BLOCKS=16 HAKMEM_L25_RUN_FACTOR=2 # Global (3) -HAKMEM_MODE=balanced -HAKMEM_FORCE_LIBC=0 +HAKMEM_MODE=fast|balanced|learning|minimal +HAKMEM_FORCE_LIBC=0|1 HAKMEM_RSS_BUDGET_KB=unlimited ``` ---- +## Migration Guidelines +- **Boundary first**: move getenv reads into init/startup boxes; expose derived knobs via globals for hot paths. +- **A/B friendly**: keep legacy names temporarily as aliases that forward to the consolidated knobs (env->new mapping) to enable rollback. +- **Visibility**: emit one-shot warnings when legacy names are used (Box Principle #4: visible, not noisy). +- **Fail-fast**: for removed knobs, fail early with a clear message instead of silently ignoring. -## Migration Guide Examples - -### Example 1: Refill Migration -```bash -# OLD (18 vars) -export HAKMEM_TINY_REFILL_MAX=64 -export HAKMEM_TINY_REFILL_MAX_HOT=192 -export HAKMEM_TINY_REFILL_COUNT=32 -export HAKMEM_TINY_REFILL_COUNT_HOT=96 -export HAKMEM_TINY_REFILL_COUNT_MID=48 +### Example 1: Refill +``` +# OLD (18 knobs) +HAKMEM_TINY_REFILL_MAX=64 +HAKMEM_TINY_REFILL_MAX_HOT=192 +HAKMEM_TINY_REFILL_COUNT=32 +HAKMEM_TINY_REFILL_COUNT_HOT=96 +HAKMEM_TINY_REFILL_COUNT_MID=48 # ... 13 more ... -# NEW (3 vars) -export HAKMEM_REFILL_BATCH=64 # Replaces *_COUNT -export HAKMEM_REFILL_HOT_BATCH=192 # Replaces *_HOT -export HAKMEM_REFILL_MAX=1024 # Replaces *_MAX +# NEW (3 knobs) +HAKMEM_REFILL_BATCH=64 +HAKMEM_REFILL_HOT_BATCH=192 +HAKMEM_REFILL_MAX=1024 ``` -### Example 2: Capacity Migration -```bash -# OLD (30+ vars) -export HAKMEM_TINY_MAG_CAP=512 -export HAKMEM_TINY_MAG_CAP_C0=256 -export HAKMEM_TINY_MAG_CAP_C1=256 +### Example 2: Capacity presets +``` +# OLD (30+ knobs) +HAKMEM_TINY_MAG_CAP=512 +HAKMEM_TINY_MAG_CAP_C0=256 +HAKMEM_TINY_MAG_CAP_C1=256 # ... 27 more ... -# NEW (1 var for most cases) -export HAKMEM_CACHE_PRESET=medium # Tiny=512, Mid=128, Large=32 - -# OR (6 vars for custom) -export HAKMEM_CACHE_PRESET=custom -export HAKMEM_TINY_CACHE_SLOTS=512 -export HAKMEM_MID_CACHE_SLOTS=128 -export HAKMEM_LARGE_CACHE_SLOTS=32 -export HAKMEM_SS_MEMORY_LIMIT_MB=512 -export HAKMEM_POOL_MEMORY_LIMIT_MB=256 +# NEW (preset) +HAKMEM_CACHE_PRESET=medium +# OR custom +HAKMEM_CACHE_PRESET=custom +HAKMEM_TINY_CACHE_SLOTS=512 +HAKMEM_MID_CACHE_SLOTS=128 +HAKMEM_LARGE_CACHE_SLOTS=32 +HAKMEM_SS_MEMORY_LIMIT_MB=512 +HAKMEM_POOL_MEMORY_LIMIT_MB=256 ``` -### Example 3: Learning Migration -```bash -# OLD (35 vars) -export HAKMEM_ACE_ENABLED=1 -export HAKMEM_INT_ENGINE=1 -export HAKMEM_INT_ADAPT_REFILL=1 -export HAKMEM_INT_ADAPT_CAPS=1 -export HAKMEM_WMAX_LEARN=1 +### Example 3: Adaptive +``` +# OLD (ACE/INT/DYN/WMAX/THP spread across 35 knobs) +HAKMEM_ACE_ENABLED=1 +HAKMEM_INT_ADAPT_REFILL=1 +HAKMEM_INT_ADAPT_CAPS=1 +HAKMEM_WMAX_LEARN=1 # ... 30 more ... -# NEW (4 vars for most cases) -export HAKMEM_ADAPTIVE_MODE=active -export HAKMEM_ADAPTIVE_TARGETS=caps,refill,wmax -export HAKMEM_ADAPTIVE_INTERVAL_MS=1000 -export HAKMEM_ADAPTIVE_AGGRESSIVENESS=0.1 +# NEW (4-8 knobs depending on depth) +HAKMEM_ADAPTIVE_MODE=active +HAKMEM_ADAPTIVE_TARGETS=caps,refill,wmax +HAKMEM_ADAPTIVE_INTERVAL_MS=1000 +HAKMEM_ADAPTIVE_AGGRESSIVENESS=0.1 ``` +## Rollout Plan +1. Add compatibility shim: map legacy names to new knobs inside `hak_core_init.inc.h` (one boundary). +2. Emit one-shot warnings for legacy names (visible, not noisy). +3. Update docs (`ENV_VARS.md`, `ENV_VARS_COMPLETE.md`) to show consolidated set and alias mapping. +4. After two releases, drop the alias layer (#ifdef guard for rollback during transition). + +## Open Questions +- Which legacy knobs need long-term support for external A/B testing? (mark in the alias table) +- Should `HAKMEM_FORCE_LIBC_ALLOC*` be absorbed into `HAKMEM_FORCE_LIBC` or kept split? +- Confirm whether per-class fastcache caps (`HAKMEM_TINY_FAST_CAP_C*`) still need independent overrides after consolidation. diff --git a/docs/analysis/SAFE_TO_DELETE_ENV_VARS.md b/docs/analysis/SAFE_TO_DELETE_ENV_VARS.md index 5be93ecf..432d44e0 100644 --- a/docs/analysis/SAFE_TO_DELETE_ENV_VARS.md +++ b/docs/analysis/SAFE_TO_DELETE_ENV_VARS.md @@ -1,158 +1,47 @@ -# ENV Variables Safe to Delete (Documentation-Only) +# ENV Variables Safe to Delete (Docs-Only, Already Off the Code Path) ## Summary -Found **21 ENV variables** that exist ONLY in documentation but have ZERO references in source code. -These are 100% safe to remove from documentation with zero risk. +- **21 ENV variables** live only in documentation; **0 getenv() hits** across `core/`, `include/`, `src/`, and `tools/`. +- These toggles were proposal placeholders; none of them ever crossed the runtime boundary. +- Status: treated as **removed from the supported surface**; only lingering mentions remain in docs archives and can be dropped when touched. -## Complete List of Docs-Only Variables +## Docs-Only Variables (21) -### 1. Pool/Refill System (1 variable) -- **HAKMEM_POOL_REFILL_BATCH** - Pool refill batch size (1-4) - - Found in: docs/status/PHASE_6.25_6.27_*.md (4 files) - - Purpose: Control batch allocation for pool refills - - Status: Feature was planned but never implemented +- HAKMEM_ALLOC_LEARN +- HAKMEM_ALLOC_LEARN_RATE +- HAKMEM_ALLOC_LEARN_WINDOW +- HAKMEM_BUILD_3LAYER +- HAKMEM_BUILD_ROUTE +- HAKMEM_DEBUG +- HAKMEM_DEBUG_LEVEL +- HAKMEM_DEBUG_TINY +- HAKMEM_EXPERIMENTAL_ADAPTIVE_DRAIN +- HAKMEM_EXPERIMENTAL_CACHE_TUNING +- HAKMEM_FORCE_LIBC +- HAKMEM_INTEGRITY_CHECKS +- HAKMEM_LEARN_ADVANCED +- HAKMEM_LEARN_DECAY +- HAKMEM_MEM_LEARN +- HAKMEM_MEM_LEARN_THRESHOLD +- HAKMEM_MEM_LEARN_WINDOW +- HAKMEM_PROFILE_SYSCALLS +- HAKMEM_STATS_ENABLE +- HAKMEM_STATS_INTERVAL_SEC +- HAKMEM_STATS_VERBOSE -### 2. Intelligence Engine (3 variables) -- **HAKMEM_INT_ENGINE** - Enable delayed intelligence/BG adaptation - - Found in: docs/specs/ENV_VARS*.md, docs/paper/ACE-Alloc/main.md (8 files) - - Purpose: Background event collection + adaptive tuning - - Status: Replaced by hakmem_tiny_background.inc (different architecture) +## How We Verified -- **HAKMEM_INT_EVENT_TS** - Event timestamp logging - - Found in: docs/specs/ENV_VARS*.md (3 files) - - Purpose: Timestamp events for intelligence engine - - Status: Never implemented +1) `rg 'getenv\\(\"HAKMEM_' core include src tools -n --sort path` → **0 matches** for all 21 names. +2) `comm -23 docs_env code_env` diff to isolate documentation-only names. +3) Spot-checked `docs/specs/ENV_VARS*.md` and related papers to ensure these are proposal artifacts, not active flags. -- **HAKMEM_INT_SAMPLE** - Intelligence sampling rate - - Found in: docs/specs/ENV_VARS*.md (4 files) - - Purpose: Sample rate for event collection - - Status: Never implemented +## Recommended Cleanup -### 3. Frontend/FastCache System (3 variables) -- **HAKMEM_TINY_FRONTEND** - Enable frontend FastCache - - Found in: docs/specs/ENV_VARS*.md (7 files) - - Purpose: Frontend hot path minimization - - Status: Evolved into different architecture - -- **HAKMEM_TINY_FASTCACHE** - FastCache control - - Found in: docs/specs/ENV_VARS*.md (5 files) - - Purpose: Control FastCache behavior - - Status: Evolved into tiny_fastcache.h (different API) - -- **HAKMEM_TINY_FAST** - Fast path enable - - Found in: docs/specs/*.md (23 files) - - Purpose: Enable fast path optimizations - - Status: Now compile-time flags, not runtime ENV - -### 4. Wrapper/Refill System (1 variable) -- **HAKMEM_WRAP_TINY_REFILL** - Wrap tiny refill operations - - Found in: docs/specs/ENV_VARS*.md (6 files) - - Purpose: Debug wrapper for refill operations - - Status: Never implemented - -### 5. Safety/Guard System (2 variables) -- **HAKMEM_SAFE_FREE_STRICT** - Strict safety checks for free - - Found in: docs/specs/ENV_VARS*.md (3 files) - - Purpose: Extra validation on free operations - - Status: Never implemented - -- **HAKMEM_TINY_GUARD** - Enable guard pages - - Found in: docs/specs/ENV_VARS*.md (1 file) - - Purpose: Guard page protection - - Status: Never implemented - -### 6. Debug/Trace System (2 variables) -- **HAKMEM_TINY_DEBUG_FAST0** - Debug fast path class 0 - - Found in: docs/specs/ENV_VARS*.md (4 files) - - Purpose: Debug logging for class 0 fast path - - Status: Never implemented - -- **HAKMEM_TINY_DEBUG_REMOTE_GUARD** - Remote free guard checks - - Found in: docs/specs/ENV_VARS*.md (7 files) - - Purpose: Guard checks for remote frees - - Status: Never implemented - -### 7. Optimization Modes (2 variables) -- **HAKMEM_TINY_QUICK** - Quick mode optimizations - - Found in: docs/specs/ENV_VARS*.md (6 files) - - Purpose: Enable quick/fast mode - - Status: Never implemented - -- **HAKMEM_USE_REGISTRY** - Use registry system - - Found in: docs/specs/ENV_VARS*.md (4 files) - - Purpose: Enable registry-based allocation - - Status: Registry is now always ON (not optional) - -### 8. TLS/SLL System (3 variables) -- **HAKMEM_TINY_TLS_LIST** - TLS list management - - Found in: docs/specs/ENV_VARS*.md (4 files) - - Purpose: Control TLS list behavior - - Status: Never implemented - -- **HAKMEM_TINY_DRAIN_TO_SLL** - Drain to SLL - - Found in: docs/specs/ENV_VARS*.md (4 files) - - Purpose: Control drain behavior to SLL - - Status: Never implemented - -- **HAKMEM_TINY_ALLOC_RING** - Allocation ring buffer - - Found in: docs/specs/ENV_VARS*.md (2 files) - - Purpose: Ring buffer for allocations - - Status: Never implemented - -### 9. Memory Management (4 variables) -- **HAKMEM_TINY_MEM_DIET** - Memory diet mode - - Found in: docs/specs/ENV_VARS*.md (8 files) - - Purpose: Reduce memory footprint - - Status: Replaced by HAKMEM_TINY_RSS_BUDGET_KB (different impl) - -- **HAKMEM_SLL_MULTIPLIER** - SLL capacity multiplier - - Found in: docs/specs/ENV_VARS*.md (2 files) - - Purpose: Scale SLL capacity - - Status: Never implemented - -- **HAKMEM_TINY_PREFETCH** - Prefetch control - - Found in: docs/specs/ENV_VARS*.md (2 files) - - Purpose: Control prefetch behavior - - Status: Never implemented - -- **HAKMEM_TINY_SS_RESERVE** - SuperSlab reserve - - Found in: docs/specs/ENV_VARS*.md (1 file) - - Purpose: Reserve SuperSlabs - - Status: Never implemented - -## Verification Process - -For each variable, verified: -1. ✅ Zero occurrences in core/*.c and core/*.h files -2. ✅ Exists only in docs/*.md files -3. ✅ Not referenced in any active code path -4. ✅ Safe to remove from documentation - -## Recommendation - -**Action**: Update ENV_VARS.md and related documentation to remove these 21 variables. - -**Impact**: -- Documentation becomes accurate -- No code changes needed -- Zero risk (variables don't exist in code) -- Improves documentation maintainability - -## Files to Update - -Primary documentation files containing these variables: -- docs/specs/ENV_VARS.md -- docs/specs/ENV_VARS_COMPLETE.md -- docs/status/PHASE_6.25_6.27_*.md -- docs/paper/ACE-Alloc/main.md +- Remove these names from `docs/specs/ENV_VARS.md`, `docs/specs/ENV_VARS_COMPLETE.md`, and any status reports when you next touch them (no code changes needed). +- Keep a single sentence in change logs noting that these toggles never existed in runtime code (A/B rollback not needed). ## Notes -These variables represent: -1. **Planned features** that were never implemented -2. **Replaced features** that evolved into different architectures -3. **Experimental features** that were abandoned -4. **Debug features** that were never needed - -All are documentation artifacts that can be safely removed. +- These were planning placeholders (adaptive tuning knobs, generic debug toggles, and early build-time experiments) that never materialized. +- Keeping them in docs increases cognitive load; deleting them is a zero-risk, reversible documentation-only change.