# OBSOLETE/ACTIVE ENV Cleanup Plan (file-by-file)

## Summary
- 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.

## Feature Decisions (keep vs. change)
- **KEEP (active)**: 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.
- **REMOVED (commit 6b791b97d, 2025-11-26)**: 6 Ultra/BG ENV vars:
  - `HAKMEM_TINY_ULTRA_FRONT`
  - `HAKMEM_TINY_ULTRA_L0`
  - `HAKMEM_TINY_ULTRA_HEAP_DUMP`
  - `HAKMEM_TINY_ULTRA_PAGE_DUMP`
  - `HAKMEM_TINY_BG_REMOTE`
  - `HAKMEM_TINY_BG_REMOTE_BATCH`
- **DEFER**: Any removal of remaining Ultra/HeapV2/BG toggles until explicit user approval; these are part of the active Box stack.

## 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/box/ultra_slim_alloc_box.h:87,226`, `core/box/hak_core_init.inc.h:279` — keep experimental toggles; require #ifdef rollback if changed.
  - **Removed in commit 6b791b97d**: `HAKMEM_TINY_ULTRA_FRONT`, `HAKMEM_TINY_ULTRA_L0`, `HAKMEM_TINY_ULTRA_HEAP_DUMP`, `HAKMEM_TINY_ULTRA_PAGE_DUMP` (files deleted: `core/front/tiny_ultrafront.h`, `core/ultra/tiny_ultra_heap.c`, `core/ultra/tiny_ultra_page_arena.c`).
- **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.

## 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.

## 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.

## Completed in this session (release gating of debug env)
- Disabled getenv for debug/trace in release builds: `HAKMEM_TINY_TRACE_RING`, `HAKMEM_TINY_DUMP_RING_ATEXIT`, `HAKMEM_TINY_RF_TRACE`, `HAKMEM_TINY_MAILBOX_TRACE(_LIMIT/_SLOWDISC/_PERIOD)`, `HAKMEM_SS_PREWARM_DEBUG`, `HAKMEM_SS_FREE_DEBUG`, `HAKMEM_TINY_FRONT_METRICS`, `HAKMEM_TINY_FRONT_DUMP`, `HAKMEM_TINY_COUNTERS_DUMP`, `HAKMEM_TINY_REFILL_DUMP`, `HAKMEM_PTR_TRACE_DUMP`, `HAKMEM_PTR_TRACE_VERBOSE`.
- SFC_DEBUG getenv consolidated to init boundary (`g_sfc_debug`).

## Appendix: Complete getenv() map (sorted by path)
```
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");
```