hakmem/core/box/hakmem_env_snapshot_box.c

// hakmem_env_snapshot_box.c - Phase 4 E1: ENV Snapshot Consolidation (implementation)
//
// E3-4 Extension: Constructor init to eliminate lazy check overhead (3.22% self%)

#include "hakmem_env_snapshot_box.h"
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include "../hakmem_build_flags.h"

// Forward declare learner check (to avoid circular deps)
extern bool small_learner_v2_enabled(void);

// Global snapshot state (TLS for thread safety)
HakmemEnvSnapshot g_hakmem_env_snapshot = {0};
int g_hakmem_env_snapshot_ready = 0;

// E3-4: Global gate state (not static local - avoids lazy init overhead)
int g_hakmem_env_snapshot_gate = -1;
int g_hakmem_env_snapshot_ctor_mode = -1;

// E3-4: Constructor - run before main() to init gate without lazy check
__attribute__((constructor(101)))
static void hakmem_env_snapshot_gate_ctor(void) {
    // Read HAKMEM_ENV_SNAPSHOT_CTOR (default OFF for safety)
    const char* ctor_env = getenv("HAKMEM_ENV_SNAPSHOT_CTOR");
    g_hakmem_env_snapshot_ctor_mode = (ctor_env && *ctor_env == '1') ? 1 : 0;

    if (g_hakmem_env_snapshot_ctor_mode) {
        // Constructor mode: init gate now (before any malloc/free calls)
        const char* e = getenv("HAKMEM_ENV_SNAPSHOT");
        g_hakmem_env_snapshot_gate = (e && *e == '1') ? 1 : 0;

#if !HAKMEM_BUILD_RELEASE
        fprintf(stderr, "[E3-4] Constructor init: HAKMEM_ENV_SNAPSHOT_GATE=%d\n",
                g_hakmem_env_snapshot_gate);
        fflush(stderr);
#endif
    }
}

// Internal helper: read all ENV vars and compute effective values
static void hakmem_env_snapshot_load(HakmemEnvSnapshot* snap) {
    // Read HAKMEM_TINY_C7_ULTRA (default: ON)
    const char* c7_env = getenv("HAKMEM_TINY_C7_ULTRA_ENABLED");
    if (c7_env && *c7_env) {
        snap->tiny_c7_ultra_enabled = (*c7_env != '0');
    } else {
        snap->tiny_c7_ultra_enabled = true;  // default: ON
    }

    // Read HAKMEM_TINY_FRONT_V3_ENABLED (default: ON)
    const char* v3_env = getenv("HAKMEM_TINY_FRONT_V3_ENABLED");
    if (v3_env && *v3_env) {
        snap->tiny_front_v3_enabled = (*v3_env != '0');
    } else {
        snap->tiny_front_v3_enabled = true;  // default: ON
    }

    // Read HAKMEM_TINY_METADATA_CACHE (default: OFF)
    const char* cache_env = getenv("HAKMEM_TINY_METADATA_CACHE");
    if (cache_env && *cache_env) {
        snap->tiny_metadata_cache = (*cache_env == '1');
    } else {
        snap->tiny_metadata_cache = false;  // default: OFF
    }

    // Compute effective metadata cache (cache && !learner)
    // Safety: disable if learner v7 is active (learner updates route_kind dynamically)
    bool learner_active = small_learner_v2_enabled();
    snap->tiny_metadata_cache_eff = snap->tiny_metadata_cache && !learner_active;

#if !HAKMEM_BUILD_RELEASE
    fprintf(stderr, "[HAKMEM_ENV_SNAPSHOT] Initialized:\n");
    fprintf(stderr, "  tiny_c7_ultra_enabled: %d\n", snap->tiny_c7_ultra_enabled);
    fprintf(stderr, "  tiny_front_v3_enabled: %d\n", snap->tiny_front_v3_enabled);
    fprintf(stderr, "  tiny_metadata_cache: %d\n", snap->tiny_metadata_cache);
    fprintf(stderr, "  tiny_metadata_cache_eff: %d (learner_active=%d)\n",
            snap->tiny_metadata_cache_eff, learner_active);
    fflush(stderr);
#endif
}

// Initialize snapshot (lazy init on first access)
void hakmem_env_snapshot_init(void) {
    if (g_hakmem_env_snapshot_ready) {
        return;  // already initialized
    }

    hakmem_env_snapshot_load(&g_hakmem_env_snapshot);
    g_hakmem_env_snapshot_ready = 1;
}

// Refresh snapshot from ENV (for bench_profile putenv sync)
// This ensures that after bench_setenv_default() runs, the snapshot is refreshed
void hakmem_env_snapshot_refresh_from_env(void) {
    // Refresh gate state too so bench_profile putenv defaults take effect even if
    // the gate was lazily initialized earlier (e.g. by pre-main malloc/free).
    const char* ctor_env = getenv("HAKMEM_ENV_SNAPSHOT_CTOR");
    g_hakmem_env_snapshot_ctor_mode = (ctor_env && *ctor_env == '1') ? 1 : 0;

    const char* gate_env = getenv("HAKMEM_ENV_SNAPSHOT");
    g_hakmem_env_snapshot_gate = (gate_env && *gate_env == '1') ? 1 : 0;

    hakmem_env_snapshot_load(&g_hakmem_env_snapshot);
    g_hakmem_env_snapshot_ready = 1;

#if !HAKMEM_BUILD_RELEASE
    fprintf(stderr, "[HAKMEM_ENV_SNAPSHOT] Refreshed from ENV (bench_profile sync)\n");
    fflush(stderr);
#endif
}