5ea6c1237b
External AI (ChatGPT Pro) implemented hierarchical refill count tuning:
- Move getenv() from hot path to init (performance hygiene)
- Add per-class granularity: global → hot/mid → per-class precedence
- Environment variables:
* HAKMEM_TINY_REFILL_COUNT (global default)
* HAKMEM_TINY_REFILL_COUNT_HOT (classes 0-3)
* HAKMEM_TINY_REFILL_COUNT_MID (classes 4-7)
* HAKMEM_TINY_REFILL_COUNT_C{0..7} (per-class override)
Performance impact: Neutral (no tuning applied yet, default=16)
- Larson 4-thread: 4.19M ops/s (unchanged)
- No measurable overhead from init-time parsing
Code quality improvement:
- Better separation: hot path reads plain ints (no syscalls)
- Future-proof: enables A/B testing per size class
- Documentation: ENV_VARS.md updated
Note: Per Ultrathink's advice, further tuning deferred until bottleneck
visualization (superslab_refill branch analysis) is complete.
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude <noreply@anthropic.com>
Co-Authored-By: ChatGPT <external-ai@openai.com>
560 lines
23 KiB
C++
560 lines
23 KiB
C++
// hakmem_tiny_init.inc
|
||
// Phase 2D-2: Initialization function extraction
|
||
//
|
||
// This file contains the hak_tiny_init() function extracted from hakmem_tiny.c
|
||
// to improve code organization. Reduces main file by 450 lines (24%).
|
||
//
|
||
// Cold path only - called once at startup.
|
||
|
||
void hak_tiny_init(void) {
|
||
if (g_tiny_initialized) return;
|
||
|
||
// Step 1: Simple initialization (static global is already zero-initialized)
|
||
g_tiny_initialized = 1;
|
||
|
||
// Reset fast-cache defaults and apply preset (if provided)
|
||
tiny_config_reset_defaults();
|
||
char* preset_env = getenv("HAKMEM_TINY_PRESET");
|
||
if (preset_env) {
|
||
if (strcasecmp(preset_env, "TIGHT") == 0) {
|
||
TINY_PRESET_TIGHT();
|
||
} else if (strcasecmp(preset_env, "ULTRA_TIGHT") == 0 ||
|
||
strcasecmp(preset_env, "ULTRATIGHT") == 0) {
|
||
TINY_PRESET_ULTRA_TIGHT();
|
||
} else {
|
||
TINY_PRESET_BALANCED();
|
||
}
|
||
}
|
||
|
||
// Phase 6.14: Read environment variable for Registry ON/OFF
|
||
char* env = getenv("HAKMEM_USE_REGISTRY");
|
||
if (env) {
|
||
g_use_registry = atoi(env);
|
||
} else {
|
||
g_use_registry = 1; // Default ON for multi-thread safety
|
||
}
|
||
|
||
// Phase 6.15: Runtime toggle to allow Tiny within wrappers
|
||
// HAKMEM_WRAP_TINY=1 → enable Tiny fast-path during wrapper calls
|
||
char* wrap_env = getenv("HAKMEM_WRAP_TINY");
|
||
if (wrap_env && atoi(wrap_env) != 0) {
|
||
g_wrap_tiny_enabled = 1;
|
||
}
|
||
char* wrap_refill_env = getenv("HAKMEM_WRAP_TINY_REFILL");
|
||
if (wrap_refill_env && atoi(wrap_refill_env) != 0) {
|
||
g_wrap_tiny_refill = 1;
|
||
}
|
||
// Remote-drain knobs
|
||
char* rth = getenv("HAKMEM_TINY_REMOTE_DRAIN_THRESHOLD");
|
||
if (rth) { int v = atoi(rth); if (v > 0) g_remote_drain_thresh = v; }
|
||
char* rr = getenv("HAKMEM_TINY_REMOTE_DRAIN_TRYRATE");
|
||
if (rr) { int v = atoi(rr); if (v > 0) g_remote_drain_tryrate = v; }
|
||
char* cs = getenv("HAKMEM_TINY_COUNT_SAMPLE");
|
||
if (cs) { int v = atoi(cs); if (v>=0 && v<=16) g_tiny_count_sample_exp = v; }
|
||
|
||
int mem_diet_enabled = 1; // Default: Enable for memory efficiency
|
||
char* memdiet_env = getenv("HAKMEM_TINY_MEM_DIET");
|
||
if (memdiet_env && atoi(memdiet_env) == 0) {
|
||
mem_diet_enabled = 0; // Allow disabling via env
|
||
}
|
||
if (mem_diet_enabled) {
|
||
if (g_mag_cap_limit > 64) g_mag_cap_limit = 64;
|
||
}
|
||
|
||
// Optional: Magazine cap limit (runtime lower bound)
|
||
char* mag_env = getenv("HAKMEM_TINY_MAG_CAP");
|
||
if (mag_env) {
|
||
int val = atoi(mag_env);
|
||
if (val > 0 && val < g_mag_cap_limit) g_mag_cap_limit = val;
|
||
}
|
||
|
||
// Phase X: Initialize TLS free-list defaults
|
||
for (int i = 0; i < TINY_NUM_CLASSES; i++) {
|
||
TinyTLSList* tls = &g_tls_lists[i];
|
||
tls->head = NULL;
|
||
tls->count = 0;
|
||
uint32_t base_cap = (uint32_t)tiny_default_cap(i);
|
||
uint32_t class_max = (uint32_t)tiny_cap_max_for_class(i);
|
||
if (base_cap > class_max) base_cap = class_max;
|
||
if ((uint32_t)g_mag_cap_limit < base_cap) base_cap = (uint32_t)g_mag_cap_limit;
|
||
if (g_mag_cap_override[i] > 0) {
|
||
uint32_t ov = (uint32_t)g_mag_cap_override[i];
|
||
if (ov > class_max) ov = class_max;
|
||
if (ov > (uint32_t)g_mag_cap_limit) ov = (uint32_t)g_mag_cap_limit;
|
||
if (ov != 0u) base_cap = ov;
|
||
}
|
||
if (base_cap == 0u) base_cap = 32u;
|
||
tls->cap = base_cap;
|
||
tls->refill_low = tiny_tls_default_refill(base_cap);
|
||
tls->spill_high = tiny_tls_default_spill(base_cap);
|
||
tiny_tls_publish_targets(i, base_cap);
|
||
}
|
||
if (mem_diet_enabled) {
|
||
tiny_apply_mem_diet();
|
||
}
|
||
|
||
// Enable signal-triggered stats dump if requested (SIGUSR1)
|
||
hak_tiny_enable_signal_dump();
|
||
|
||
// Phase 6.23: SuperSlab support (mimalloc-style fast allocation)
|
||
// Allow runtime disable/enable via env (0=off, 1=on)
|
||
char* superslab_env = getenv("HAKMEM_TINY_USE_SUPERSLAB");
|
||
if (superslab_env) {
|
||
g_use_superslab = (atoi(superslab_env) != 0) ? 1 : 0;
|
||
} else if (mem_diet_enabled) {
|
||
g_use_superslab = 0; // Diet mode: disable SuperSlab to minimize memory
|
||
}
|
||
// One-shot hint: publish/adopt requires SuperSlab ON
|
||
{
|
||
static int hint_once = 0;
|
||
if (!hint_once) {
|
||
const char* must_adopt = getenv("HAKMEM_TINY_MUST_ADOPT");
|
||
if ((!superslab_env || g_use_superslab == 0) && must_adopt && atoi(must_adopt) != 0) {
|
||
fprintf(stderr, "[HINT] HAKMEM_TINY_USE_SUPERSLAB=0: publish/adopt pipeline is disabled. Set =1 for mailbox/adopt.\n");
|
||
}
|
||
hint_once = 1;
|
||
}
|
||
}
|
||
{
|
||
char* tlslist_env = getenv("HAKMEM_TINY_TLS_LIST");
|
||
if (tlslist_env) {
|
||
g_tls_list_enable = (atoi(tlslist_env) != 0) ? 1 : 0;
|
||
}
|
||
}
|
||
// Phase 9.4: TLS SLL toggle (default ON)
|
||
char* sll_env = getenv("HAKMEM_TINY_TLS_SLL");
|
||
if (sll_env && atoi(sll_env) == 0) {
|
||
g_tls_sll_enable = 0;
|
||
}
|
||
// Path debug enabled?
|
||
{
|
||
char* pd = getenv("HAKMEM_TINY_PATH_DEBUG");
|
||
g_path_debug_enabled = (pd && atoi(pd) != 0) ? 1 : 0;
|
||
}
|
||
// Ultra-Bump TLS shadow（既定ON、envでOFF可能）
|
||
{
|
||
char* ub = getenv("HAKMEM_TINY_BUMP_SHADOW");
|
||
if (ub) { g_ultra_bump_shadow = (atoi(ub) != 0) ? 1 : 0; }
|
||
char* bc = getenv("HAKMEM_TINY_BUMP_CHUNK");
|
||
if (bc) { int v = atoi(bc); if (v > 0 && v < 32768) g_bump_chunk = v; }
|
||
}
|
||
// Refill-one-on-miss（チェーン生成を避け、1個だけ確保して返す）
|
||
{
|
||
char* ro = getenv("HAKMEM_TINY_REFILL_ONE_ON_MISS");
|
||
if (ro) g_refill_one_on_miss = (atoi(ro) != 0) ? 1 : 0;
|
||
}
|
||
// SLL multiplier (hot tiny classes)
|
||
char* sllmul = getenv("HAKMEM_SLL_MULTIPLIER");
|
||
if (sllmul) {
|
||
int v = atoi(sllmul);
|
||
if (v < 1) {
|
||
v = 1;
|
||
} else if (v > 16) {
|
||
v = 16; // guardrail
|
||
}
|
||
g_sll_multiplier = v;
|
||
}
|
||
|
||
// HotMag enable / tuning（既定OFF, envでON可）
|
||
{
|
||
char* hm = getenv("HAKMEM_TINY_HOTMAG");
|
||
if (hm) g_hotmag_enable = (atoi(hm) != 0) ? 1 : 0;
|
||
char* hmcap = getenv("HAKMEM_TINY_HOTMAG_CAP");
|
||
if (hmcap) {
|
||
int v = atoi(hmcap);
|
||
if (v < 16) v = 16;
|
||
else if (v > 1024) v = 1024;
|
||
g_hotmag_cap_default = v;
|
||
}
|
||
char* hmrefill = getenv("HAKMEM_TINY_HOTMAG_REFILL");
|
||
if (hmrefill) {
|
||
int v = atoi(hmrefill);
|
||
if (v < 0) v = 0;
|
||
if (v > g_hotmag_cap_default) v = g_hotmag_cap_default;
|
||
g_hotmag_refill_default = v;
|
||
}
|
||
if (g_hotmag_refill_default > g_hotmag_cap_default) {
|
||
g_hotmag_refill_default = g_hotmag_cap_default;
|
||
}
|
||
if (g_hotmag_refill_default < 0) g_hotmag_refill_default = 0;
|
||
|
||
for (int k = 0; k < TINY_NUM_CLASSES; k++) {
|
||
uint16_t cap = hotmag_effective_cap(k);
|
||
g_hotmag_cap_current[k] = cap;
|
||
g_hotmag_cap_locked[k] = 0;
|
||
uint16_t refill = (uint16_t)g_hotmag_refill_default;
|
||
if (refill > cap) refill = cap;
|
||
g_hotmag_refill_current[k] = refill;
|
||
g_hotmag_refill_locked[k] = 0;
|
||
g_hotmag_class_en[k] = (k <= 3) ? 1 : 0;
|
||
}
|
||
|
||
// Heuristic defaults for the three hottest classes when not overridden
|
||
if (!g_hotmag_cap_locked[0]) {
|
||
uint16_t cap = g_hotmag_cap_current[0];
|
||
uint16_t cap_target = (g_hotmag_cap_default > 48) ? 48 : (uint16_t)g_hotmag_cap_default;
|
||
if (cap_target < 16) cap_target = 16;
|
||
if (cap_target < cap) g_hotmag_cap_current[0] = cap_target;
|
||
}
|
||
if (!g_hotmag_cap_locked[1]) {
|
||
uint16_t cap = g_hotmag_cap_current[1];
|
||
uint16_t cap_target = (g_hotmag_cap_default > 80) ? 80 : (uint16_t)g_hotmag_cap_default;
|
||
if (cap_target < 32) cap_target = 32;
|
||
if (cap_target < cap) g_hotmag_cap_current[1] = cap_target;
|
||
}
|
||
if (!g_hotmag_cap_locked[2]) {
|
||
uint16_t cap = g_hotmag_cap_current[2];
|
||
uint16_t cap_target = (g_hotmag_cap_default > 112) ? 112 : (uint16_t)g_hotmag_cap_default;
|
||
if (cap_target < 48) cap_target = 48;
|
||
if (cap_target < cap) g_hotmag_cap_current[2] = cap_target;
|
||
}
|
||
|
||
if (!g_hotmag_refill_locked[0]) {
|
||
g_hotmag_refill_current[0] = 0;
|
||
}
|
||
if (!g_hotmag_refill_locked[1]) {
|
||
uint16_t cap = g_hotmag_cap_current[1];
|
||
uint16_t ref = (g_hotmag_refill_default > 0) ? (uint16_t)g_hotmag_refill_default : 0;
|
||
if (ref > 0) {
|
||
uint16_t limit = (cap > 20) ? 20 : cap;
|
||
if (ref > limit) ref = limit;
|
||
if (ref > cap) ref = cap;
|
||
}
|
||
g_hotmag_refill_current[1] = ref;
|
||
}
|
||
if (!g_hotmag_refill_locked[2]) {
|
||
uint16_t cap = g_hotmag_cap_current[2];
|
||
uint16_t ref = (g_hotmag_refill_default > 0) ? (uint16_t)g_hotmag_refill_default : 0;
|
||
if (ref > 0) {
|
||
uint16_t limit = (cap > 40) ? 40 : cap;
|
||
if (ref > limit) ref = limit;
|
||
if (ref > cap) ref = cap;
|
||
}
|
||
g_hotmag_refill_current[2] = ref;
|
||
}
|
||
|
||
// Default: disable class 2 (32B) HotMag entirely unless explicitly enabled by env
|
||
if (!getenv("HAKMEM_TINY_HOTMAG_C2")) {
|
||
g_hotmag_class_en[2] = 0;
|
||
}
|
||
|
||
for (int k = 0; k < TINY_NUM_CLASSES; k++) {
|
||
char key_cap[64];
|
||
snprintf(key_cap, sizeof(key_cap), "HAKMEM_TINY_HOTMAG_CAP_C%d", k);
|
||
char* cap_env = getenv(key_cap);
|
||
if (cap_env) {
|
||
int v = atoi(cap_env);
|
||
if (v < 16) v = 16;
|
||
else if (v > 1024) v = 1024;
|
||
g_hotmag_cap_current[k] = (uint16_t)v;
|
||
g_hotmag_cap_locked[k] = 1;
|
||
if (!g_hotmag_refill_locked[k] && g_hotmag_refill_current[k] > g_hotmag_cap_current[k]) {
|
||
g_hotmag_refill_current[k] = g_hotmag_cap_current[k];
|
||
}
|
||
}
|
||
char key_ref[64];
|
||
snprintf(key_ref, sizeof(key_ref), "HAKMEM_TINY_HOTMAG_REFILL_C%d", k);
|
||
char* ref_env = getenv(key_ref);
|
||
if (ref_env) {
|
||
int v = atoi(ref_env);
|
||
if (v < 0) v = 0;
|
||
if (v > g_hotmag_cap_current[k]) v = g_hotmag_cap_current[k];
|
||
g_hotmag_refill_current[k] = (uint16_t)v;
|
||
g_hotmag_refill_locked[k] = 1;
|
||
}
|
||
char key_en[64];
|
||
snprintf(key_en, sizeof(key_en), "HAKMEM_TINY_HOTMAG_C%d", k);
|
||
char* en_env = getenv(key_en);
|
||
if (en_env) {
|
||
g_hotmag_class_en[k] = (uint8_t)((atoi(en_env) != 0) ? 1 : 0);
|
||
}
|
||
}
|
||
|
||
for (int k = 0; k < TINY_NUM_CLASSES; k++) {
|
||
if (g_hotmag_enable && hkm_is_hot_class(k)) {
|
||
g_tls_hot_mag[k].cap = g_hotmag_cap_current[k];
|
||
} else {
|
||
g_tls_hot_mag[k].cap = 0; // lazy init
|
||
}
|
||
g_tls_hot_mag[k].top = 0;
|
||
}
|
||
}
|
||
|
||
// Ultra-Simple front enable（既定OFF, A/B用）
|
||
{
|
||
char* us = getenv("HAKMEM_TINY_ULTRA_SIMPLE");
|
||
if (us) g_ultra_simple = (atoi(us) != 0) ? 1 : 0;
|
||
// zero-initialized by default
|
||
}
|
||
|
||
// Background Refill Bin（既定OFF, A/B用）
|
||
{
|
||
char* bb = getenv("HAKMEM_TINY_BG_BIN");
|
||
if (bb) g_bg_bin_enable = (atoi(bb) != 0) ? 1 : 0;
|
||
char* bt = getenv("HAKMEM_TINY_BG_TARGET");
|
||
if (bt) { int v = atoi(bt); if (v > 0 && v <= 4096) g_bg_bin_target = v; }
|
||
for (int k = 0; k < TINY_NUM_CLASSES; k++) {
|
||
atomic_store_explicit(&g_bg_bin_head[k], (uintptr_t)0, memory_order_relaxed);
|
||
}
|
||
if (g_bg_bin_enable && !g_bg_bin_started) {
|
||
if (pthread_create(&g_bg_bin_thread, NULL, tiny_bg_refill_main, NULL) == 0) {
|
||
g_bg_bin_started = 1;
|
||
} else {
|
||
g_bg_bin_enable = 0; // disable on failure
|
||
}
|
||
}
|
||
}
|
||
// Background Spill/Drain (integrated into bg thread)
|
||
// EXTRACTED: bg_spill init moved to hakmem_tiny_bg_spill.c (Phase 2C-2)
|
||
{
|
||
bg_spill_init(); // Initialize bg_spill module from environment
|
||
|
||
// Remote target queue init (Phase 2C-1)
|
||
char* br = getenv("HAKMEM_TINY_BG_REMOTE");
|
||
if (br) g_bg_remote_enable = (atoi(br) != 0) ? 1 : 0;
|
||
char* rb = getenv("HAKMEM_TINY_BG_REMOTE_BATCH");
|
||
if (rb) { int v = atoi(rb); if (v > 0 && v <= 4096) g_bg_remote_batch = v; }
|
||
for (int k = 0; k < TINY_NUM_CLASSES; k++) {
|
||
atomic_store_explicit(&g_remote_target_head[k], (uintptr_t)0, memory_order_relaxed);
|
||
atomic_store_explicit(&g_remote_target_len[k], 0u, memory_order_relaxed);
|
||
}
|
||
|
||
// bg thread already started above if bg_bin_enable=1; if only spill is enabled, start thread
|
||
if (g_bg_spill_enable && !g_bg_bin_started) {
|
||
if (pthread_create(&g_bg_bin_thread, NULL, tiny_bg_refill_main, NULL) == 0) {
|
||
g_bg_bin_started = 1;
|
||
g_bg_bin_enable = 1; // reuse loop
|
||
} else {
|
||
g_bg_spill_enable = 0;
|
||
}
|
||
}
|
||
}
|
||
// Optional prefetch enable
|
||
{
|
||
char* pf = getenv("HAKMEM_TINY_PREFETCH");
|
||
if (pf && atoi(pf) != 0) g_tiny_prefetch = 1;
|
||
}
|
||
// Refill batch tuning
|
||
char* rmax = getenv("HAKMEM_TINY_REFILL_MAX");
|
||
if (rmax) { int v = atoi(rmax); if (v > 0) g_tiny_refill_max = v; }
|
||
char* rmaxh = getenv("HAKMEM_TINY_REFILL_MAX_HOT");
|
||
if (rmaxh) { int v = atoi(rmaxh); if (v > 0) g_tiny_refill_max_hot = v; }
|
||
// Per-class overrides: HAKMEM_TINY_REFILL_MAX_C{0..7}, HAKMEM_TINY_REFILL_MAX_HOT_C{0..7}
|
||
for (int k = 0; k < TINY_NUM_CLASSES; k++) {
|
||
char key1[64]; snprintf(key1, sizeof(key1), "HAKMEM_TINY_REFILL_MAX_C%d", k);
|
||
char* v1 = getenv(key1); if (v1) { int vv = atoi(v1); if (vv > 0) g_refill_max_c[k] = vv; }
|
||
char key2[64]; snprintf(key2, sizeof(key2), "HAKMEM_TINY_REFILL_MAX_HOT_C%d", k);
|
||
char* v2 = getenv(key2); if (v2) { int vv = atoi(v2); if (vv > 0) g_refill_max_hot_c[k] = vv; }
|
||
}
|
||
// Stats sampling rate (compile-time gated) via env HAKMEM_TINY_STAT_RATE_LG
|
||
#if defined(HAKMEM_ENABLE_STATS) && defined(HAKMEM_TINY_STAT_SAMPLING)
|
||
{
|
||
char* sr = getenv("HAKMEM_TINY_STAT_RATE_LG");
|
||
if (sr) { int lg = atoi(sr); if (lg >= 0 && lg <= 31) g_stat_rate_lg = lg; }
|
||
// 関数ポインタ選択（分岐をホットパスから排除）
|
||
g_stat_alloc_fn = (g_stat_rate_lg == 0) ? hkm_stat_alloc_always : hkm_stat_alloc_sampled;
|
||
}
|
||
#elif defined(HAKMEM_ENABLE_STATS)
|
||
// サンプリング未使用時は毎回更新
|
||
// FIXME: g_stat_alloc_fn and hkm_stat_alloc_always not yet implemented
|
||
// Stats are recorded via hkm_stat_alloc() in HAK_RET_ALLOC macro instead
|
||
// g_stat_alloc_fn = hkm_stat_alloc_always;
|
||
#endif
|
||
|
||
// Spill hysteresis（freeホットパスでgetenvしない）
|
||
{
|
||
char* sh = getenv("HAKMEM_TINY_SPILL_HYST");
|
||
if (sh) { int v = atoi(sh); if (v < 0) v = 0; g_spill_hyst = v; }
|
||
}
|
||
char* ultra_env = getenv("HAKMEM_TINY_ULTRA");
|
||
if (ultra_env && atoi(ultra_env) != 0) {
|
||
g_tiny_ultra = 1;
|
||
}
|
||
char* uval = getenv("HAKMEM_TINY_ULTRA_VALIDATE");
|
||
if (uval && atoi(uval) != 0) {
|
||
g_ultra_validate = 1;
|
||
}
|
||
|
||
// Ultra env overrides: per-class batch and sll_cap
|
||
// HAKMEM_TINY_ULTRA_BATCH_C{0..7}, HAKMEM_TINY_ULTRA_SLL_CAP_C{0..7}
|
||
char var[64];
|
||
for (int i = 0; i < TINY_NUM_CLASSES; i++) {
|
||
snprintf(var, sizeof(var), "HAKMEM_TINY_ULTRA_BATCH_C%d", i);
|
||
char* vb = getenv(var);
|
||
if (vb) { int v = atoi(vb); if (v > 0) g_ultra_batch_override[i] = v; }
|
||
snprintf(var, sizeof(var), "HAKMEM_TINY_ULTRA_SLL_CAP_C%d", i);
|
||
char* vc = getenv(var);
|
||
if (vc) { int v = atoi(vc); if (v > 0) g_ultra_sll_cap_override[i] = v; }
|
||
// Normal-path per-class overrides
|
||
snprintf(var, sizeof(var), "HAKMEM_TINY_MAG_CAP_C%d", i);
|
||
char* vm = getenv(var);
|
||
if (vm) { int v = atoi(vm); if (v > 0 && v <= TINY_TLS_MAG_CAP) g_mag_cap_override[i] = v; }
|
||
snprintf(var, sizeof(var), "HAKMEM_TINY_SLL_CAP_C%d", i);
|
||
char* vs = getenv(var);
|
||
if (vs) { int v = atoi(vs); if (v > 0 && v <= TINY_TLS_MAG_CAP) g_sll_cap_override[i] = v; }
|
||
|
||
// Front refill count per-class override (fast path tuning)
|
||
snprintf(var, sizeof(var), "HAKMEM_TINY_REFILL_COUNT_C%d", i);
|
||
char* rc = getenv(var);
|
||
if (rc) { int v = atoi(rc); if (v < 0) v = 0; if (v > 256) v = 256; g_refill_count_class[i] = v; }
|
||
}
|
||
|
||
// Front refill count globals
|
||
{
|
||
char* g = getenv("HAKMEM_TINY_REFILL_COUNT");
|
||
if (g) { int v = atoi(g); if (v < 0) v = 0; if (v > 256) v = 256; g_refill_count_global = v; }
|
||
char* h = getenv("HAKMEM_TINY_REFILL_COUNT_HOT");
|
||
if (h) { int v = atoi(h); if (v < 0) v = 0; if (v > 256) v = 256; g_refill_count_hot = v; }
|
||
char* m = getenv("HAKMEM_TINY_REFILL_COUNT_MID");
|
||
if (m) { int v = atoi(m); if (v < 0) v = 0; if (v > 256) v = 256; g_refill_count_mid = v; }
|
||
}
|
||
{
|
||
char* fast_env = getenv("HAKMEM_TINY_FAST");
|
||
if (fast_env && atoi(fast_env) == 0) g_fast_enable = 0;
|
||
int fast_global = -1;
|
||
char* fast_cap_env = getenv("HAKMEM_TINY_FAST_CAP");
|
||
if (fast_cap_env) {
|
||
int v = atoi(fast_cap_env);
|
||
if (v >= 0 && v <= TINY_TLS_MAG_CAP) fast_global = v;
|
||
}
|
||
for (int i = 0; i < TINY_NUM_CLASSES; i++) {
|
||
uint16_t cap = g_fast_cap_defaults[i];
|
||
if (fast_global >= 0) cap = (uint16_t)fast_global;
|
||
snprintf(var, sizeof(var), "HAKMEM_TINY_FAST_CAP_C%d", i);
|
||
char* fc = getenv(var);
|
||
if (fc) {
|
||
int v = atoi(fc);
|
||
if (v < 0) v = 0;
|
||
if (v > TINY_TLS_MAG_CAP) v = TINY_TLS_MAG_CAP;
|
||
cap = (uint16_t)v;
|
||
g_fast_cap_locked[i] = 1;
|
||
} else if (fast_global >= 0) {
|
||
g_fast_cap_locked[i] = 1;
|
||
} else {
|
||
g_fast_cap_locked[i] = 0;
|
||
}
|
||
g_fast_cap[i] = cap;
|
||
}
|
||
}
|
||
|
||
{
|
||
const char* dbg_fast = getenv("HAKMEM_TINY_DEBUG_FAST0");
|
||
if (dbg_fast && atoi(dbg_fast) != 0) {
|
||
g_debug_fast0 = 1;
|
||
g_fast_enable = 0;
|
||
g_hotmag_enable = 0;
|
||
g_tls_list_enable = 0;
|
||
}
|
||
const char* dbg_remote = getenv("HAKMEM_TINY_DEBUG_REMOTE_GUARD");
|
||
if (dbg_remote && atoi(dbg_remote) != 0) {
|
||
g_debug_remote_guard = 1;
|
||
}
|
||
const char* rf_force = getenv("HAKMEM_TINY_RF_FORCE_NOTIFY");
|
||
if (rf_force && atoi(rf_force) != 0) {
|
||
extern int g_remote_force_notify;
|
||
g_remote_force_notify = 1;
|
||
}
|
||
const char* safe_free = getenv("HAKMEM_SAFE_FREE");
|
||
if (safe_free && atoi(safe_free) != 0) {
|
||
extern int g_tiny_safe_free; g_tiny_safe_free = 1;
|
||
}
|
||
const char* safe_free_strict = getenv("HAKMEM_SAFE_FREE_STRICT");
|
||
if (safe_free_strict && atoi(safe_free_strict) != 0) {
|
||
extern int g_tiny_safe_free_strict; g_tiny_safe_free_strict = 1;
|
||
}
|
||
const char* force_remote = getenv("HAKMEM_TINY_FORCE_REMOTE");
|
||
if (force_remote && atoi(force_remote) != 0) {
|
||
extern int g_tiny_force_remote; g_tiny_force_remote = 1;
|
||
}
|
||
// Remote side-table (debug only)
|
||
tiny_remote_side_init_from_env();
|
||
}
|
||
static int g_super_trace = -1;
|
||
if (__builtin_expect(g_super_trace == -1, 0)) {
|
||
const char* tr = getenv("HAKMEM_TINY_SUPERSLAB_TRACE");
|
||
g_super_trace = (tr && atoi(tr) != 0) ? 1 : 0;
|
||
}
|
||
if (g_super_trace) {
|
||
static int logged_once = 0;
|
||
if (!logged_once) {
|
||
fprintf(stderr, "[SUPERTRACE] mem_diet=%d env=%s g_use_superslab=%d fast_enable=%d cap0=%u cap1=%u cap2=%u cap3=%u cap4=%u reslist=%d\n",
|
||
mem_diet_enabled,
|
||
superslab_env ? superslab_env : "(null)",
|
||
g_use_superslab,
|
||
g_fast_enable,
|
||
(unsigned)g_fast_cap[0],
|
||
(unsigned)g_fast_cap[1],
|
||
(unsigned)g_fast_cap[2],
|
||
(unsigned)g_fast_cap[3],
|
||
(unsigned)g_fast_cap[4],
|
||
g_tls_list_enable);
|
||
logged_once = 1;
|
||
}
|
||
}
|
||
tiny_ace_init_defaults();
|
||
char* fc_env = getenv("HAKMEM_TINY_FASTCACHE");
|
||
if (fc_env && atoi(fc_env) != 0) {
|
||
g_fastcache_enable = 1;
|
||
}
|
||
char* fe_env = getenv("HAKMEM_TINY_FRONTEND");
|
||
if (fe_env && atoi(fe_env) != 0) {
|
||
g_frontend_enable = 1;
|
||
}
|
||
// TinyQuickSlot opt-in
|
||
{
|
||
char* q = getenv("HAKMEM_TINY_QUICK");
|
||
if (q && atoi(q) != 0) g_quick_enable = 1;
|
||
}
|
||
|
||
tiny_obs_start_if_needed();
|
||
|
||
// Deferred Intelligence Engine
|
||
char* ie = getenv("HAKMEM_INT_ENGINE");
|
||
if (ie && atoi(ie) != 0) {
|
||
g_int_engine = 1;
|
||
// Initialize frontend fill targets to zero (let engine grow if hot)
|
||
for (int i = 0; i < TINY_NUM_CLASSES; i++) atomic_store(&g_frontend_fill_target[i], 0);
|
||
// Event logging knobs (optional)
|
||
char* its = getenv("HAKMEM_INT_EVENT_TS");
|
||
if (its && atoi(its) != 0) g_int_event_ts = 1;
|
||
char* ism = getenv("HAKMEM_INT_SAMPLE");
|
||
if (ism) { int n = atoi(ism); if (n > 0 && n < 31) g_int_sample_mask = ((1u << n) - 1u); }
|
||
if (pthread_create(&g_int_thread, NULL, intelligence_engine_main, NULL) == 0) {
|
||
g_int_started = 1;
|
||
}
|
||
}
|
||
|
||
// Step 2: Initialize Slab Registry (only if enabled)
|
||
if (g_use_registry) {
|
||
memset(g_slab_registry, 0, sizeof(g_slab_registry));
|
||
}
|
||
|
||
// Initialize per-class locks
|
||
for (int i = 0; i < TINY_NUM_CLASSES; i++) {
|
||
pthread_mutex_init(&g_tiny_class_locks[i].m, NULL);
|
||
}
|
||
|
||
// Phase 8.3: Initialize ACE (Adaptive Cache Engine) state
|
||
for (int i = 0; i < TINY_NUM_CLASSES; i++) {
|
||
g_ss_ace[i].current_lg = 20; // Start with 1MB SuperSlabs
|
||
g_ss_ace[i].target_lg = 20; // Default to 1MB
|
||
g_ss_ace[i].hot_score = 0;
|
||
g_ss_ace[i].alloc_count = 0;
|
||
g_ss_ace[i].refill_count = 0;
|
||
g_ss_ace[i].spill_count = 0;
|
||
g_ss_ace[i].live_blocks = 0;
|
||
g_ss_ace[i].last_tick_ns = 0;
|
||
}
|
||
|
||
// Lite P1: Pre-allocate Tier 1 (8-64B) hot classes only
|
||
// This avoids initialization overhead for common small allocations
|
||
// Classes 0-3: 8B, 16B, 32B, 64B (256KB total, not 512KB)
|
||
for (int class_idx = 0; class_idx < 4; class_idx++) {
|
||
TinySlab* slab = allocate_new_slab(class_idx);
|
||
if (slab) {
|
||
slab->next = g_tiny_pool.free_slabs[class_idx];
|
||
g_tiny_pool.free_slabs[class_idx] = slab;
|
||
}
|
||
}
|
||
}
|