From 6b791b97d4d71ea4761a1ac11260bb8fd112a86d Mon Sep 17 00:00:00 2001 From: "Moe Charm (CI)" Date: Thu, 27 Nov 2025 04:35:47 +0900 Subject: [PATCH] ENV Cleanup: Delete Ultra HEAP & BG Remote dead code (-1,096 LOC) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Deleted files (11): - core/ultra/ directory (6 files: tiny_ultra_heap.*, tiny_ultra_page_arena.*) - core/front/tiny_ultrafront.h - core/tiny_ultra_fast.inc.h - core/hakmem_tiny_ultra_front.inc.h - core/hakmem_tiny_ultra_simple.inc - core/hakmem_tiny_ultra_batch_box.inc Edited files (10): - core/hakmem_tiny.c: Remove Ultra HEAP #includes, move ultra_batch_for_class() - core/hakmem_tiny_tls_state_box.inc: Delete TinyUltraFront, g_ultra_simple - core/hakmem_tiny_phase6_wrappers_box.inc: Delete ULTRA_SIMPLE block - core/hakmem_tiny_alloc.inc: Delete Ultra-Front code block - core/hakmem_tiny_init.inc: Delete ULTRA_SIMPLE ENV loading - core/hakmem_tiny_remote_target.{c,h}: Delete g_bg_remote_enable/batch - core/tiny_refill.h: Remove BG Remote check (always break) - core/hakmem_tiny_background.inc: Delete BG Remote drain loop Deleted ENV variables: - HAKMEM_TINY_ULTRA_HEAP (build flag, undefined) - HAKMEM_TINY_ULTRA_L0 - HAKMEM_TINY_ULTRA_HEAP_DUMP - HAKMEM_TINY_ULTRA_PAGE_DUMP - HAKMEM_TINY_ULTRA_FRONT - HAKMEM_TINY_BG_REMOTE (no getenv, dead code) - HAKMEM_TINY_BG_REMOTE_BATCH (no getenv, dead code) - HAKMEM_TINY_ULTRA_SIMPLE (references only) Impact: - Code reduction: -1,096 lines - Binary size: 305KB → 304KB (-1KB) - Build: PASS - Sanity: 15.69M ops/s (3 runs avg) - Larson: 1 crash observed (seed 43, likely existing instability) Notes: - Ultra HEAP never compiled (#if HAKMEM_TINY_ULTRA_HEAP undefined) - BG Remote variables never initialized (g_bg_remote_enable always 0) - Ultra SLIM (ultra_slim_alloc_box.h) preserved (active 4-layer path) 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude --- core/box/front_gate_classifier.d | 4 +- core/front/tiny_ultrafront.h | 123 ------------ core/hakmem_tiny.c | 68 ++++--- core/hakmem_tiny_alloc.inc | 14 +- core/hakmem_tiny_background.inc | 22 +-- core/hakmem_tiny_init.inc | 7 +- core/hakmem_tiny_phase6_wrappers_box.inc | 20 +- core/hakmem_tiny_remote_target.c | 3 +- core/hakmem_tiny_remote_target.h | 3 +- core/hakmem_tiny_tls_state_box.inc | 35 +--- core/hakmem_tiny_ultra_batch_box.inc | 20 -- core/hakmem_tiny_ultra_front.inc.h | 52 ----- core/hakmem_tiny_ultra_simple.inc | 235 ----------------------- core/tiny_refill.h | 8 +- core/tiny_ultra_fast.inc.h | 102 ---------- core/ultra/tiny_ultra_heap.c | 203 -------------------- core/ultra/tiny_ultra_heap.d | 4 - core/ultra/tiny_ultra_heap.h | 71 ------- core/ultra/tiny_ultra_page_arena.c | 87 --------- core/ultra/tiny_ultra_page_arena.d | 24 --- core/ultra/tiny_ultra_page_arena.h | 41 ---- hakmem.d | 11 +- 22 files changed, 61 insertions(+), 1096 deletions(-) delete mode 100644 core/front/tiny_ultrafront.h delete mode 100644 core/hakmem_tiny_ultra_batch_box.inc delete mode 100644 core/hakmem_tiny_ultra_front.inc.h delete mode 100644 core/hakmem_tiny_ultra_simple.inc delete mode 100644 core/tiny_ultra_fast.inc.h delete mode 100644 core/ultra/tiny_ultra_heap.c delete mode 100644 core/ultra/tiny_ultra_heap.d delete mode 100644 core/ultra/tiny_ultra_heap.h delete mode 100644 core/ultra/tiny_ultra_page_arena.c delete mode 100644 core/ultra/tiny_ultra_page_arena.d delete mode 100644 core/ultra/tiny_ultra_page_arena.h diff --git a/core/box/front_gate_classifier.d b/core/box/front_gate_classifier.d index 2db2743d..c694ea8b 100644 --- a/core/box/front_gate_classifier.d +++ b/core/box/front_gate_classifier.d @@ -15,7 +15,8 @@ core/box/front_gate_classifier.o: core/box/front_gate_classifier.c \ core/box/../hakmem_build_flags.h core/box/../hakmem_internal.h \ core/box/../hakmem.h core/box/../hakmem_config.h \ core/box/../hakmem_features.h core/box/../hakmem_sys.h \ - core/box/../hakmem_whale.h core/box/../hakmem_tiny_config.h + core/box/../hakmem_whale.h core/box/../hakmem_tiny_config.h \ + core/box/../pool_tls_registry.h core/box/front_gate_classifier.h: core/box/../tiny_region_id.h: core/box/../hakmem_build_flags.h: @@ -42,3 +43,4 @@ core/box/../hakmem_features.h: core/box/../hakmem_sys.h: core/box/../hakmem_whale.h: core/box/../hakmem_tiny_config.h: +core/box/../pool_tls_registry.h: diff --git a/core/front/tiny_ultrafront.h b/core/front/tiny_ultrafront.h deleted file mode 100644 index a2b4a050..00000000 --- a/core/front/tiny_ultrafront.h +++ /dev/null @@ -1,123 +0,0 @@ -// tiny_ultrafront.h - Phase UltraFront: 密結合 Tiny Front Path (実験箱) -// -// 目的: -// - 既存の FrontGate + Unified Cache を前提に、 -// malloc/free の Tiny 経路を「1本のインラインパス」に近づける実験的フロント。 -// - Box Theory 的には Front 層の別バリアント Box として扱い、 -// ENV で A/B 切り替え可能にする。 -// -// 特徴: -// - Tiny 範囲 (size <= tiny_get_max_size()) 専用。 -// - Unified Cache を直接叩く (unified_cache_pop_or_refill / unified_cache_push)。 -// - Header 書き込み/読取りは tiny_region_id_* を利用して安全性を維持。 -// -// ENV: -// HAKMEM_TINY_ULTRA_FRONT=1 ... UltraFront 有効 (デフォルト: 0, 無効) -// -// 統合ポイント: -// - malloc ラッパ (hak_wrappers.inc.h) の FrontGate ブロック内から -// tiny_ultrafront_malloc(size) を first try として呼び出す。 -// - free ラッパから tiny_ultrafront_free(ptr) を first try として呼び出す。 - -#ifndef HAK_FRONT_TINY_ULTRA_FRONT_H -#define HAK_FRONT_TINY_ULTRA_FRONT_H - -#include -#include -#include "../hakmem_build_flags.h" -#include "../hakmem_tiny.h" // tiny_get_max_size, hak_tiny_size_to_class -// #include "tiny_unified_cache.h" // Removed (A/B test: OFF is faster) -#include "../tiny_region_id.h" // tiny_region_id_write_header / read_header - -// ============================================================================ -// ENV Control (cached, lazy init) -// ============================================================================ - -static inline int tiny_ultrafront_enabled(void) { - static int g_enable = -1; - if (__builtin_expect(g_enable == -1, 0)) { - const char* e = getenv("HAKMEM_TINY_ULTRA_FRONT"); - g_enable = (e && *e && *e != '0') ? 1 : 0; -#if !HAKMEM_BUILD_RELEASE - if (g_enable) { - fprintf(stderr, "[UltraFront-INIT] tiny_ultrafront_enabled() = %d\n", g_enable); - fflush(stderr); - } -#endif - } - return g_enable; -} - -// ============================================================================ -// UltraFront malloc/free (Tiny 専用) -// ============================================================================ - -// UltraFront Tiny allocation -// - size: ユーザー要求サイズ -// - 戻り値: USER ポインタ or NULL (Unified miss時は通常経路にフォールバックさせる) -static inline void* tiny_ultrafront_malloc(size_t size) { - // Tiny 範囲外は扱わない - if (__builtin_expect(size == 0 || size > tiny_get_max_size(), 0)) { - return NULL; - } - - // サイズ→クラス (branchless LUT) - int class_idx = hak_tiny_size_to_class(size); - if (__builtin_expect(class_idx < 0 || class_idx >= TINY_NUM_CLASSES, 0)) { - return NULL; - } - - // Unified Cache から BASE を取得 (hit or refill) - // DELETED (A/B test: OFF is faster) - // void* base = unified_cache_pop_or_refill(class_idx); - // if (__builtin_expect(base == NULL, 0)) { - // // Unified Cache disabled or refill failed → 通常経路にフォールバック - // return NULL; - // } - - // Unified Cache removed → 通常経路にフォールバック - return NULL; -} - -// UltraFront Tiny free -// - ptr: USER ポインタ -// - 戻り値: 1=UltraFront で処理済み, 0=フォールバック (通常 free 経路へ) -static inline int tiny_ultrafront_free(void* ptr) { - if (__builtin_expect(!ptr, 0)) { - return 0; - } - -#if HAKMEM_TINY_HEADER_CLASSIDX - // ページ境界ガード: ptr がページ先頭 (offset==0) の場合、ptr-1 は - // 別ページ/未マップ領域となり得るので UltraFront では扱わない。 - uintptr_t off = (uintptr_t)ptr & 0xFFFu; - if (__builtin_expect(off == 0, 0)) { - return 0; - } - - // Header ベースの class_idx 読取り (tiny_region_id_read_header は magic/範囲チェック込み) - int class_idx = tiny_region_id_read_header(ptr); - if (__builtin_expect(class_idx < 0 || class_idx >= TINY_NUM_CLASSES, 0)) { - // Tiny ヘッダが無い or 壊れている → 非Tiny / 別ドメインなのでフォールバック - return 0; - } - - // void* base = (void*)((uint8_t*)ptr - 1); - - // Unified Cache へ BASE を push - // DELETED (A/B test: OFF is faster) - // int pushed = unified_cache_push(class_idx, base); - // if (__builtin_expect(pushed, 1)) { - // return 1; - // } - - // Unified Cache removed → 通常 free 経路へ - return 0; -#else - // ヘッダモードでなければ UltraFront は何もしない - (void)ptr; - return 0; -#endif -} - -#endif // HAK_FRONT_TINY_ULTRA_FRONT_H diff --git a/core/hakmem_tiny.c b/core/hakmem_tiny.c index fdf63c21..d4775b84 100644 --- a/core/hakmem_tiny.c +++ b/core/hakmem_tiny.c @@ -31,10 +31,7 @@ #include "hakmem_prof.h" #include "hakmem_trace.h" // Optional USDT (perf) tracepoints -// Phase E5: Ultra fast path (8-instruction alloc/free) -#if HAKMEM_ULTRA_FAST_PATH -#include "tiny_ultra_fast.inc.h" -#endif +// Phase E5: Ultra fast path - REMOVED (dead code cleanup 2025-11-27) extern uint64_t g_bytes_allocated; // from hakmem_tiny_superslab.c @@ -252,8 +249,40 @@ inline void hakmem_thread_register(void) { } } -// Forward declarations for helpers referenced by frontend_refill_fc -static inline int ultra_batch_for_class(int class_idx); +// SLL capacity override array (moved from deleted hakmem_tiny_ultra_batch_box.inc) +static int g_ultra_batch_override[TINY_NUM_CLASSES] = {0}; +static int g_ultra_sll_cap_override[TINY_NUM_CLASSES] = {0}; + +// Helper function for batch size (moved from deleted hakmem_tiny_ultra_batch_box.inc) +static inline int ultra_batch_for_class(int class_idx) { + int ov = g_ultra_batch_override[class_idx]; + if (ov > 0) return ov; + switch (class_idx) { + case 0: return 64; // 8B + case 1: return 96; // 16B + case 2: return 96; // 32B + case 3: return 224; // 64B + case 4: return 96; // 128B + case 5: return 64; // 256B + case 6: return 64; // 512B + default: return 32; // 1024B and others + } +} + +// Helper function for SLL capacity (moved from deleted hakmem_tiny_ultra_batch_box.inc) +static inline int ultra_sll_cap_for_class(int class_idx) { + int ov = g_ultra_sll_cap_override[class_idx]; + if (ov > 0) return ov; + switch (class_idx) { + case 0: return 256; // 8B + case 1: return 384; // 16B + case 2: return 384; // 32B + case 3: return 768; // 64B + case 4: return 256; // 128B + default: return 128; // others + } +} + enum { HAK_TIER_SLL=1, HAK_TIER_MAG=2, HAK_TIER_SLAB=3, HAK_TIER_SUPER=4, HAK_TIER_FRONT=5 }; @@ -342,18 +371,7 @@ static inline void* hak_tiny_alloc_superslab_try_fast(int class_idx) { // ============================================================================ // Function: bulk_mag_to_sll_if_room() - 22 lines (lines 1133-1154) -// Ultra helpers forward declarations (defined later) -static inline int ultra_sll_cap_for_class(int class_idx); -static inline int ultra_validate_sll_head(int class_idx, void* head); - -// Ultra-Mode Batch Configuration - EXTRACTED to hakmem_tiny_ultra_batch_box.inc -#include "hakmem_tiny_ultra_batch_box.inc" - - -// ============================================================================ -// EXTRACTED TO hakmem_tiny_refill.inc.h (Phase 2D-1) -// ============================================================================ -// Function: ultra_refill_sll() - 56 lines (lines 1178-1233) +// Ultra-Mode Batch Configuration - REMOVED (dead code cleanup 2025-11-27) #include "hakmem_tiny_remote.inc" @@ -528,19 +546,7 @@ __attribute__((weak)) int sll_refill_batch_from_ss(int class_idx, int max_take) // Forward decl for internal registry lookup used by ultra safety validation static TinySlab* registry_lookup(uintptr_t slab_base); -// Ultra helpers: per-class SLL cap and pointer validation -static inline int ultra_sll_cap_for_class(int class_idx) { - int ov = g_ultra_sll_cap_override[class_idx]; - if (ov > 0) return ov; - switch (class_idx) { - case 0: return 256; // 8B - case 1: return 384; // 16B（A/B最良） - case 2: return 384; // 32B（A/B最良） - case 3: return 768; // 64B（A/B最良） - case 4: return 256; // 128B - default: return 128; // others - } -} +// ultra_sll_cap_for_class moved earlier in file (before hakmem_tiny_free.inc) static inline int ultra_validate_sll_head(int class_idx, void* head) { uintptr_t base = ((uintptr_t)head) & ~(TINY_SLAB_SIZE - 1); diff --git a/core/hakmem_tiny_alloc.inc b/core/hakmem_tiny_alloc.inc index e92fcb40..319d2ade 100644 --- a/core/hakmem_tiny_alloc.inc +++ b/core/hakmem_tiny_alloc.inc @@ -209,19 +209,7 @@ void* hak_tiny_alloc(size_t size) { } #endif - // Ultra-Front: minimal per-class stack for hot tiny classes (opt-in) - // Try ultra_pop → (optional) ultra_refill_small → ultra_pop before other layers - if (__builtin_expect(g_ultra_simple && class_idx <= 3, 0)) { - void* up = ultra_pop(class_idx); - if (__builtin_expect(up == NULL, 0)) { - (void)ultra_refill_small(class_idx); - up = ultra_pop(class_idx); - } - if (__builtin_expect(up != NULL, 0)) { - tiny_debug_ring_record(TINY_RING_EVENT_ALLOC_SUCCESS, (uint16_t)class_idx, up, 0xF0); - HAK_RET_ALLOC_WITH_METRIC(up); - } - } + // Ultra-Front - REMOVED (dead code cleanup 2025-11-27) if (__builtin_expect(!g_debug_fast0, 1)) { #ifdef HAKMEM_TINY_BENCH_FASTPATH diff --git a/core/hakmem_tiny_background.inc b/core/hakmem_tiny_background.inc index 6f6276ba..7cf66c9c 100644 --- a/core/hakmem_tiny_background.inc +++ b/core/hakmem_tiny_background.inc @@ -14,7 +14,8 @@ static int g_bg_bin_started = 0; // ============================================================================ // Targeted remote-drain queue moved to separate module // Functions: remote_target_enqueue(), remote_target_pop() -// Variables: g_bg_remote_enable, g_remote_target_head, g_remote_target_len, g_bg_remote_batch +// Variables: g_remote_target_head, g_remote_target_len +// NOTE: g_bg_remote_enable, g_bg_remote_batch REMOVED (dead code cleanup 2025-11-27) // ============================================================================ // EXTRACTED TO hakmem_tiny_bg_spill.c/.h (Phase 2C-2) @@ -71,23 +72,8 @@ static void* tiny_bg_refill_main(void* arg) { bg_spill_drain_class(k, lock); } } - // Drain remote frees: targeted by per-class queue (avoid scanning all slabs) - if (g_bg_remote_enable) { - for (int k = 0; k < TINY_NUM_CLASSES; k++) { - int processed = 0; - while (processed < g_bg_remote_batch) { - TinySlab* s = remote_target_pop(k); - if (!s) break; - pthread_mutex_t* lock = &g_tiny_class_locks[k].m; - pthread_mutex_lock(lock); - tiny_remote_drain_locked(s); - pthread_mutex_unlock(lock); - processed++; - // If more remain (due to concurrent pushes), the slab may be re-enqueued - // by producers when threshold is hit again. - } - } - } + // Drain remote frees - REMOVED (dead code cleanup 2025-11-27) + // The g_bg_remote_enable feature was never enabled in production usleep(sleep_us); } return NULL; diff --git a/core/hakmem_tiny_init.inc b/core/hakmem_tiny_init.inc index 9f83cf1e..5a4632b6 100644 --- a/core/hakmem_tiny_init.inc +++ b/core/hakmem_tiny_init.inc @@ -183,12 +183,7 @@ void hak_tiny_init(void) { g_sll_multiplier = v; } - // 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 - } + // Ultra-Simple front - REMOVED (dead code cleanup 2025-11-27) // Background Bin/Spill/Remote: runtime ENV toggles removed (fixed OFF) // Initialize heads to keep structures consistent. diff --git a/core/hakmem_tiny_phase6_wrappers_box.inc b/core/hakmem_tiny_phase6_wrappers_box.inc index a7ce59d4..e29ea405 100644 --- a/core/hakmem_tiny_phase6_wrappers_box.inc +++ b/core/hakmem_tiny_phase6_wrappers_box.inc @@ -97,25 +97,7 @@ } } -#elif defined(HAKMEM_TINY_PHASE6_ULTRA_SIMPLE) - // Phase 6-1.5: Alignment guessing (legacy) - - // Refill count globals (needed for compatibility) - int g_refill_count_global = 0; - int g_refill_count_hot = 0; - int g_refill_count_mid = 0; - int g_refill_count_class[TINY_NUM_CLASSES] = {0}; - - #include "hakmem_tiny_ultra_simple.inc" - - // Wrapper functions for hakmem.c compatibility (not used in ULTRA_SIMPLE but needed for linking) - void* hak_tiny_alloc_fast_wrapper(size_t size) { - return hak_tiny_alloc_ultra_simple(size); - } - - void hak_tiny_free_fast_wrapper(void* ptr) { - hak_tiny_free_ultra_simple(ptr); - } +// HAKMEM_TINY_PHASE6_ULTRA_SIMPLE - REMOVED (dead code cleanup 2025-11-27) #elif defined(HAKMEM_TINY_PHASE6_METADATA) // Phase 6-1.6: Metadata header (recommended) #include "hakmem_tiny_metadata.inc" diff --git a/core/hakmem_tiny_remote_target.c b/core/hakmem_tiny_remote_target.c index 76cbc928..fcf50835 100644 --- a/core/hakmem_tiny_remote_target.c +++ b/core/hakmem_tiny_remote_target.c @@ -2,10 +2,9 @@ #include "hakmem_tiny.h" // For TinySlab definition // Global variables -int g_bg_remote_enable = 0; // HAKMEM_TINY_BG_REMOTE=1 +// BG Remote variables REMOVED (dead code cleanup 2025-11-27) _Atomic uintptr_t g_remote_target_head[TINY_NUM_CLASSES]; _Atomic uint32_t g_remote_target_len[TINY_NUM_CLASSES]; -int g_bg_remote_batch = 32; // HAKMEM_TINY_BG_REMOTE_BATCH void remote_target_enqueue(int class_idx, TinySlab* slab) { // Best-effort: mark as enqueued once to avoid duplicate pushes diff --git a/core/hakmem_tiny_remote_target.h b/core/hakmem_tiny_remote_target.h index 48228596..94477efa 100644 --- a/core/hakmem_tiny_remote_target.h +++ b/core/hakmem_tiny_remote_target.h @@ -11,10 +11,9 @@ typedef struct TinySlab TinySlab; // Targeted remote-drain queue: Slabs with high remote free counts // Background thread can drain these without blocking allocation hot path -extern int g_bg_remote_enable; +// BG Remote variables REMOVED (dead code cleanup 2025-11-27) extern _Atomic uintptr_t g_remote_target_head[TINY_NUM_CLASSES]; extern _Atomic uint32_t g_remote_target_len[TINY_NUM_CLASSES]; -extern int g_bg_remote_batch; // Enqueue a slab for targeted remote drain (lock-free Treiber stack) void remote_target_enqueue(int class_idx, TinySlab* slab); diff --git a/core/hakmem_tiny_tls_state_box.inc b/core/hakmem_tiny_tls_state_box.inc index de845ec0..ba60f149 100644 --- a/core/hakmem_tiny_tls_state_box.inc +++ b/core/hakmem_tiny_tls_state_box.inc @@ -176,47 +176,18 @@ void hak_tiny_prewarm_tls_cache(void) { } #endif -// Ultra-Simple front (small per-class stack) — combines tiny front to minimize -// instructions and memory touches on alloc/free. Uses existing TLS bump shadow -// (g_tls_bcur/bend) when enabled to avoid per-alloc header writes. -// UltraFront capacity for 32/64B fast pop -#ifndef ULTRA_FRONT_CAP -#define ULTRA_FRONT_CAP 64 -#endif -typedef struct __attribute__((aligned(64))) { - void* slots[ULTRA_FRONT_CAP]; - uint16_t top; // 0..ULTRA_FRONT_CAP - uint16_t _pad; -} TinyUltraFront; -static int g_ultra_simple = 0; // HAKMEM_TINY_ULTRA_SIMPLE=1 -static __thread TinyUltraFront g_tls_ultra[TINY_NUM_CLASSES]; -// Inline helpers -#include "hakmem_tiny_ultra_front.inc.h" +// Ultra-Simple front - REMOVED (dead code cleanup 2025-11-27) -// Ultra-Bump TLS shadow (bench/opt-in): keep a TLS-only bump window -// to avoid per-alloc header writes. Header is updated per-chunk reservation. -// NOTE: Non-static because used in hakmem_tiny_refill.inc.h -int g_bump_chunk = 32; // HAKMEM_TINY_BUMP_CHUNK (blocks) -__thread uint8_t* g_tls_bcur[TINY_NUM_CLASSES] = {0}; -__thread uint8_t* g_tls_bend[TINY_NUM_CLASSES] = {0}; - -// SLL small refill batch for specialized class (32/64B) -// Specialized order toggle: 1 = mag-first, 0 = sll-first // HotMag helpers (for classes 0..3) static inline int is_hot_class(int class_idx) { return class_idx >= 0 && class_idx <= 3; } -// Optional front (Ultra/HotMag) push helper: compile-out in release builds +// Optional front (HotMag) push helper: compile-out in release builds static inline int tiny_optional_push(int class_idx, void* ptr) { #if HAKMEM_BUILD_RELEASE (void)class_idx; (void)ptr; return 0; #else - if (__builtin_expect(g_ultra_simple && is_hot_class(class_idx), 0)) { - if (__builtin_expect(ultra_push(class_idx, ptr), 0)) { - return 1; - } - } if (__builtin_expect(is_hot_class(class_idx), 0)) { if (__builtin_expect(hotmag_push(class_idx, ptr), 0)) { return 1; @@ -226,8 +197,6 @@ static inline int tiny_optional_push(int class_idx, void* ptr) { #endif } -// Ultra-Simple helpers - // Phase 9.6: Deferred Intelligence (event queue + background) // Extended event for FLINT Intelligence (lightweight; recorded off hot path only) // Observability, ACE, and intelligence helpers diff --git a/core/hakmem_tiny_ultra_batch_box.inc b/core/hakmem_tiny_ultra_batch_box.inc deleted file mode 100644 index ad2c691d..00000000 --- a/core/hakmem_tiny_ultra_batch_box.inc +++ /dev/null @@ -1,20 +0,0 @@ - -// Ultra-mode (SLL-only) helpers -// Ultra batch overrides via env: HAKMEM_TINY_ULTRA_BATCH_C{0..7} -static int g_ultra_batch_override[TINY_NUM_CLASSES] = {0}; -static int g_ultra_sll_cap_override[TINY_NUM_CLASSES] = {0}; - -static inline int ultra_batch_for_class(int class_idx) { - int ov = g_ultra_batch_override[class_idx]; - if (ov > 0) return ov; - switch (class_idx) { - case 0: return 64; // 8B - case 1: return 96; // 16B（A/B最良） - case 2: return 96; // 32B（A/B最良） - case 3: return 224; // 64B（A/B最良） - case 4: return 96; // 128B (promote front refill a bit) - case 5: return 64; // 256B (promote front refill) - case 6: return 64; // 512B (promote front refill) - default: return 32; // 1024B and others - } -} diff --git a/core/hakmem_tiny_ultra_front.inc.h b/core/hakmem_tiny_ultra_front.inc.h deleted file mode 100644 index 773ac665..00000000 --- a/core/hakmem_tiny_ultra_front.inc.h +++ /dev/null @@ -1,52 +0,0 @@ -// Inline helpers for Ultra-Simple TLS front (tiny per-class stack + bump) -// This header is textually included from hakmem_tiny.c after the following -// symbols are defined: -// - static int g_ultra_simple; -// - static __thread TinyUltraFront g_tls_ultra[]; -// - __thread void* g_tls_sll_head[]; __thread uint32_t g_tls_sll_count[]; -// - tiny_mag_init_if_needed(), g_tls_mags[] - -#include "box/tls_sll_box.h" // Box TLS-SLL API - -static inline void ultra_init_if_needed(int class_idx) { - if (!g_ultra_simple || class_idx < 0) return; - // nothing to do; zero-initialized -} - -static inline void* ultra_pop(int class_idx) { - if (!g_ultra_simple) return NULL; - TinyUltraFront* uf = &g_tls_ultra[class_idx]; - if (__builtin_expect(uf->top > 0, 1)) { - return uf->slots[--uf->top]; - } - return NULL; -} - -static inline int ultra_push(int class_idx, void* ptr) { - if (!g_ultra_simple) return 0; - TinyUltraFront* uf = &g_tls_ultra[class_idx]; - if (__builtin_expect(uf->top < ULTRA_FRONT_CAP, 1)) { uf->slots[uf->top++] = ptr; return 1; } - return 0; -} - -static inline int ultra_refill_small(int class_idx) { - if (!g_ultra_simple) return 0; - TinyUltraFront* uf = &g_tls_ultra[class_idx]; - int room = ULTRA_FRONT_CAP - (int)uf->top; if (room <= 0) return 0; - int took = 0; - if (g_tls_sll_enable) { - while (room > 0) { - void* h = NULL; - if (!tls_sll_pop(class_idx, &h)) break; - uf->slots[uf->top++] = h; room--; took++; - } - } - if (room > 0) { - tiny_mag_init_if_needed(class_idx); - TinyTLSMag* mag = &g_tls_mags[class_idx]; - int take = mag->top < room ? mag->top : room; - for (int i = 0; i < take; i++) uf->slots[uf->top++] = mag->items[--mag->top].ptr; - took += take; - } - return took; -} diff --git a/core/hakmem_tiny_ultra_simple.inc b/core/hakmem_tiny_ultra_simple.inc deleted file mode 100644 index ce3de43c..00000000 --- a/core/hakmem_tiny_ultra_simple.inc +++ /dev/null @@ -1,235 +0,0 @@ -// hakmem_tiny_ultra_simple.inc -// Phase 6-1.5: Ultra-Simple Fast Path integrated with existing HAKMEM -// -// Design: "Simple Front + Smart Back" (inspired by Mid-Large HAKX +171%) -// - Front: Ultra-simple TLS SLL (reuse existing g_tls_sll_head[]) -// - Back: Existing SuperSlab + ACE + Learning layer -// -// Key insight: HAKMEM already HAS the infrastructure! -// - g_tls_sll_head[] exists (line 492 of hakmem_tiny.c) -// - sll_refill_small_from_ss() exists (hakmem_tiny_refill.inc.h:187) -// - Just need to remove the overhead layers! - -#ifndef HAKMEM_TINY_ULTRA_SIMPLE_INC -#define HAKMEM_TINY_ULTRA_SIMPLE_INC - -// SFC integration -#include "tiny_alloc_fast_sfc.inc.h" -#include "box/tls_sll_box.h" // Box TLS-SLL API - -// ============================================================================ -// Phase 6-1.5: Ultra-Simple Allocator (uses existing infrastructure) -// ============================================================================ -// This replaces the complex multi-layer fast path with a 3-4 instruction path -// while keeping all existing backend infrastructure (SuperSlab, ACE, Learning) - -// Forward declarations for external TLS variables and functions -extern __thread TinyTLSSLL g_tls_sll[TINY_NUM_CLASSES]; - -static __thread int g_ultra_simple_called = 0; - -// NOTE: These functions are NOT static because they need to be called from hakmem.c -// They MUST be defined in hakmem_tiny.c where TLS variables are accessible -void* hak_tiny_alloc_ultra_simple(size_t size) { - // DEBUG: Mark that we're using ultra_simple path (disabled in release) -#ifdef HAKMEM_DEBUG_VERBOSE - if (!g_ultra_simple_called) { - fprintf(stderr, "[PHASE 6-1.5] Ultra-simple path ACTIVE!\n"); - g_ultra_simple_called = 1; - } -#endif - - // 1. Size → class (inline function, existing) - int class_idx = hak_tiny_size_to_class(size); - if (__builtin_expect(class_idx < 0, 0)) { - return NULL; // >1KB - } - - // 2. Ultra-fast path: Pop from existing TLS SLL (Phase 6-1 style!) - // This is IDENTICAL to Phase 6-1 but uses existing g_tls_sll_head[] - void* head = NULL; - if (tls_sll_pop(class_idx, &head)) { - HAK_RET_ALLOC(class_idx, head); - } - - // 3. Miss: Refill from existing SuperSlab infrastructure - // This gives us ACE, Learning layer, L25 integration for free! - // Tunable refill count (env: HAKMEM_TINY_REFILL_COUNT, default 32) - static int s_refill_count = 0; - if (__builtin_expect(s_refill_count == 0, 0)) { - int def = 32; // smaller refill improves warm-up and reuse density - char* env = getenv("HAKMEM_TINY_REFILL_COUNT"); - int v = (env ? atoi(env) : def); - if (v < 8) v = 8; // clamp to sane range - if (v > 256) v = 256; - s_refill_count = v; - } - int refill_count = s_refill_count; -#if HAKMEM_TINY_P0_BATCH_REFILL - if (sll_refill_batch_from_ss(class_idx, refill_count) > 0) { -#else - if (sll_refill_small_from_ss(class_idx, refill_count) > 0) { -#endif - if (tls_sll_pop(class_idx, &head)) { - HAK_RET_ALLOC(class_idx, head); - } - } - - // 4. Fallback to slow path (existing infrastructure) - void* slow_ptr = hak_tiny_alloc_slow(size, class_idx); - if (slow_ptr) { - HAK_RET_ALLOC(class_idx, slow_ptr); - } - return slow_ptr; -} - -// ============================================================================ -// Ultra-Simple Free Path (bypasses free.part.0 complexity) -// ============================================================================ -// This eliminates the 38.43% free path overhead identified by perf analysis: -// - free.part.0: 15.83% -// - mid_lookup: 9.55% -// - pthread locks: 8.81% -// Just 2-3 instructions: owner check → push to TLS SLL - -static __thread int g_ultra_simple_free_called = 0; -static __thread uint64_t g_ultra_simple_free_count = 0; - -// Ultra-fast class guess from pointer alignment (Phase 6-1.6: CTZ optimization) -// This is FAST but may be wrong - validation happens later! -static inline int guess_class_from_alignment(void* ptr) { - uintptr_t addr = (uintptr_t)ptr; - - // Quick check: not 8-byte aligned → not Tiny - if (__builtin_expect((addr & 7) != 0, 0)) return -1; - - // Fast path: Use Count Trailing Zeros (1 instruction!) - // Tiny classes: 8B(cls0), 16B(cls1), 32B(cls2), 64B(cls3), 128B(cls4), 256B(cls5), 512B(cls6), 1KB(cls7) - // 8B: addr ends ...000 → ctz=3 → cls=0 - // 16B: addr ends ...0000 → ctz=4 → cls=1 - // 32B: addr ends ...00000 → ctz=5 → cls=2 - // 64B: addr ends ...000000 → ctz=6 → cls=3 - int trailing_zeros = __builtin_ctzl(addr); - int class_idx = trailing_zeros - 3; // Subtract 3 (log2(8)) - - // Clamp to valid range (0-7 for Tiny classes) - if (__builtin_expect(class_idx < 0 || class_idx >= TINY_NUM_CLASSES, 0)) { - return -1; // Invalid alignment - } - - return class_idx; -} - -// NOTE: This function is NOT static because it needs to be called from hakmem.c -// It MUST be defined in hakmem_tiny.c where TLS variables are accessible -void hak_tiny_free_ultra_simple(void* ptr) { - // DEBUG: Mark that we're using ultra_simple free path (always enabled for SFC debug) - static __thread int free_entry_count = 0; - if (getenv("HAKMEM_SFC_DEBUG") && free_entry_count < 20) { - free_entry_count++; - fprintf(stderr, "[ULTRA_FREE_ENTRY] ptr=%p, count=%d\n", ptr, free_entry_count); - } - -#ifdef HAKMEM_DEBUG_VERBOSE - if (!g_ultra_simple_free_called) { - fprintf(stderr, "[PHASE 6-1.5] Ultra-simple FREE path ACTIVE (LAZY VALIDATION)!\n"); - g_ultra_simple_free_called = 1; - } -#endif - - // Prefer safe same-thread detection over pure alignment guessing to avoid - // capturing cross-thread frees into the wrong TLS SLL (Larson MT case). - - // 1) SuperSlab-backed tiny pointer? - if (__builtin_expect(g_use_superslab != 0, 1)) { - SuperSlab* ss = hak_super_lookup(ptr); - if (__builtin_expect(ss != NULL && ss->magic == SUPERSLAB_MAGIC, 0)) { - // ✅ FIX: Phase E1-CORRECT - Convert USER → BASE before slab index calculation - void* base = (void*)((uint8_t*)ptr - 1); - int slab_idx = slab_index_for(ss, base); - TinySlabMeta* meta = &ss->slabs[slab_idx]; - uint32_t self_tid = tiny_self_u32(); - if (__builtin_expect(meta->owner_tid == self_tid, 1)) { - int class_idx = ss->size_class; - - // SFC Integration: Same as tiny_free_fast_ss() in tiny_free_fast.inc.h - extern int g_sfc_enabled; - - // Debug: Track ultra_simple free path (SFC integration) - BEFORE SFC call - static __thread int ultra_free_debug_count = 0; - if (getenv("HAKMEM_SFC_DEBUG") && ultra_free_debug_count < 20) { - ultra_free_debug_count++; - fprintf(stderr, "[ULTRA_FREE_SS] ptr=%p, cls=%d, sfc_enabled=%d\n", - ptr, class_idx, g_sfc_enabled); - } - - if (g_sfc_enabled) { - // Try SFC (128 slots) - // Debug: Log before calling sfc_free_push - static __thread int push_attempt_count = 0; - if (getenv("HAKMEM_SFC_DEBUG") && push_attempt_count < 20) { - push_attempt_count++; - fprintf(stderr, "[ULTRA_FREE_PUSH_ATTEMPT] cls=%d, ptr=%p\n", class_idx, ptr); - } - - if (!sfc_free_push(class_idx, ptr)) { - // SFC full → skip caching, delegate to slow path - // Do NOT fall back to SLL - it has no capacity check! - hak_tiny_free(ptr); - return; - } - } else { - // Old SLL path (16 slots) - Use Box TLS-SLL API - if (!tls_sll_push(class_idx, ptr, UINT32_MAX)) { - // C7 rejected or capacity exceeded - fallback to slow path - hak_tiny_free(ptr); - return; - } - } - - // Active accounting on free - ss_active_dec_one(ss); - return; - } - // Cross-thread free → delegate to full tiny free - hak_tiny_free(ptr); - return; - } - } - - // 2) Legacy TinySlab-backed pointer? - TinySlab* slab = hak_tiny_owner_slab(ptr); - if (__builtin_expect(slab != NULL, 0)) { - if (__builtin_expect(pthread_equal(slab->owner_tid, tiny_self_pt()), 1)) { - int class_idx = slab->class_idx; - - // SFC Integration: Same as tiny_free_fast_legacy() in tiny_free_fast.inc.h - extern int g_sfc_enabled; - if (g_sfc_enabled) { - // Try SFC (128 slots) - if (!sfc_free_push(class_idx, ptr)) { - // SFC full → skip caching, delegate to slow path - // Do NOT fall back to SLL - it has no capacity check! - hak_tiny_free_with_slab(ptr, slab); - return; - } - } else { - // Old SLL path (16 slots) - Use Box TLS-SLL API - if (!tls_sll_push(class_idx, ptr, UINT32_MAX)) { - // C7 rejected or capacity exceeded - fallback to slow path - hak_tiny_free_with_slab(ptr, slab); - return; - } - } - return; - } - // Cross-thread free → precise path with known slab - hak_tiny_free_with_slab(ptr, slab); - return; - } - - // 3) Fallback: Not a tiny allocation (or unknown) → delegate - hak_free_at(ptr, 0, 0); -} - -#endif // HAKMEM_TINY_ULTRA_SIMPLE_INC diff --git a/core/tiny_refill.h b/core/tiny_refill.h index 11bc1da9..4ae66052 100644 --- a/core/tiny_refill.h +++ b/core/tiny_refill.h @@ -268,11 +268,11 @@ static inline SuperSlab* tiny_refill_try_fast(int class_idx, TinyTLSSlab* tls) { } } // Opportunistic background remote-drain (Box: Remote Drain Coalescer) - // Every N misses, coalesce a few remote queues into freelists under ownership + // NOTE: BG Remote feature permanently disabled (dead code cleanup 2025-11-27) + // This block was guarded by g_bg_remote_enable which defaulted to 0 do { - // ENV gate: HAKMEM_TINY_BG_REMOTE=1 enables this light step - extern int g_bg_remote_enable; // from hakmem_tiny_remote_target.c - if (__builtin_expect(!g_bg_remote_enable, 1)) break; + // Always skip - BG Remote feature removed + break; // TLS miss tick per class static __thread unsigned miss_tick[8]; diff --git a/core/tiny_ultra_fast.inc.h b/core/tiny_ultra_fast.inc.h deleted file mode 100644 index f77db9e7..00000000 --- a/core/tiny_ultra_fast.inc.h +++ /dev/null @@ -1,102 +0,0 @@ -#ifndef TINY_ULTRA_FAST_INC_H -#define TINY_ULTRA_FAST_INC_H - -// ============================================================================ -// HAKMEM Ultra Fast Path -// ============================================================================ -// Phase E5: System malloc並みの超軽量fast path -// -// 目的: -// - FastCache/SFC/統計/プロファイリングを全てOFF -// - TLS SLL 1層のみのシンプル実装 -// - 8-10命令でalloc/freeを完結 -// -// 期待: -// - System malloc並みの性能 (90M+ ops/s) -// - 「賢い機能」のコストを定量化 -// ============================================================================ - -#include "hakmem_tiny.h" - -// External TLS arrays (defined in hakmem_tiny.c) -// Phase 3d-B: TLS Cache Merge - Unified structure (type in hakmem_tiny.h) -extern __thread TinyTLSSLL g_tls_sll[TINY_NUM_CLASSES]; - -// ============================================================================ -// Ultra-Fast Allocation (8-10 instructions) -// ============================================================================ -static inline void* tiny_alloc_ultra_fast(size_t size) { - // 1. Size to class (direct calculation, no LUT) - // HAKMEM Tiny classes (from g_tiny_class_sizes): - // C0=8B, C1=16B, C2=32B, C3=64B, C4=128B, C5=256B, C6=512B, C7=1024B - if (size == 0) size = 1; - if (size > 1024) return NULL; // Tiny範囲外 - - // Direct mapping: use BSR-style or simple branching - int cl; - if (size <= 8) cl = 0; - else if (size <= 16) cl = 1; - else if (size <= 32) cl = 2; - else if (size <= 64) cl = 3; - else if (size <= 128) cl = 4; - else if (size <= 256) cl = 5; - else if (size <= 512) cl = 6; - else cl = 7; // size <= 1024 - - // 2. TLS SLL pop (3-4 instructions) - // Phase 3d-B: Use unified struct (head+count in same cache line) - void* ptr = g_tls_sll[cl].head; // 1 load - if (!ptr) return NULL; // 1 branch (miss → slow path) - - void* next = *(void**)ptr; // 1 load (next pointer) - g_tls_sll[cl].head = next; // 1 store - g_tls_sll[cl].count--; // 1 decrement - - // 3. Return USER pointer (ptr is BASE, +1 for header) - // Phase 7 header-based fast free requires this - return (char*)ptr + 1; -} - -// ============================================================================ -// Ultra-Fast Free (6-8 instructions) -// ============================================================================ -static inline int tiny_free_ultra_fast(void* ptr) { - if (!ptr) return 0; - - // 1. Read header to get class_idx (Phase 7 header-based) - uint8_t header = *((uint8_t*)ptr - 1); - uint8_t class_idx = header & 0x0F; - - // 2. Bounds check (safety - minimal overhead) - if (class_idx >= TINY_NUM_CLASSES) return 0; // Route to slow path - - // 3. Convert USER → BASE - void* base = (char*)ptr - 1; - - // 4. TLS SLL push (3-4 instructions) - // Phase 3d-B: Use unified struct (head+count in same cache line) - void* head = g_tls_sll[class_idx].head; // 1 load - *(void**)base = head; // 1 store (link) - g_tls_sll[class_idx].head = base; // 1 store - g_tls_sll[class_idx].count++; // 1 increment - - return 1; // Success -} - -// ============================================================================ -// Ultra Mode Entry Point - TLS SLL Only (no fallback) -// ============================================================================ -// NOTE: Ultra mode expects TLS SLL to be warm. If miss, returns NULL. -// Caller (wrapper) will fallback to full tiny_alloc_fast path. - -static inline void* tiny_alloc_fast_ultra(size_t size) { - // Try ultra-fast path (TLS SLL only) - return tiny_alloc_ultra_fast(size); -} - -static inline void tiny_free_fast_ultra(void* ptr) { - // Try ultra-fast free (TLS SLL push only) - tiny_free_ultra_fast(ptr); -} - -#endif // TINY_ULTRA_FAST_INC_H diff --git a/core/ultra/tiny_ultra_heap.c b/core/ultra/tiny_ultra_heap.c deleted file mode 100644 index 64452496..00000000 --- a/core/ultra/tiny_ultra_heap.c +++ /dev/null @@ -1,203 +0,0 @@ -#include "tiny_ultra_heap.h" - -#if HAKMEM_TINY_ULTRA_HEAP - -// TinyTLS slab 配列は既存 Tiny 層の「page/local slab ビュー」 -// UltraHeap ではこれを Box 経由で見るだけに留める（挙動はまだ変えない）。 -extern __thread TinyTLSSlab g_tls_slabs[TINY_NUM_CLASSES]; - -// Unified front removed (A/B test: OFF is faster) -// #include "../front/tiny_unified_cache.h" -#include "../tiny_region_id.h" -#include "../hakmem_tiny_unified_stats.h" -#include -#include - -__thread TinyUltraHeap g_tiny_ultra_heap = {0}; - -// UltraHeap L0 キャッシュ制御 (ENV: HAKMEM_TINY_ULTRA_L0) -static inline int tiny_ultra_l0_enabled(void) -{ - static int g_enable = -1; - if (__builtin_expect(g_enable == -1, 0)) { - const char* e = getenv("HAKMEM_TINY_ULTRA_L0"); - // デフォルト: 無効（0）。明示的に 1 を指定した場合のみ有効化。 - g_enable = (e && *e && *e != '0') ? 1 : 0; - } - return g_enable; -} - -// L0 から 1 ブロック取得（BASE を返す） -static inline void* -tiny_ultra_heap_l0_pop(TinyUltraHeap* heap, int class_idx) -{ - if (!tiny_ultra_l0_enabled()) { - return NULL; - } - TinyUltraL0* l0 = &heap->l0[class_idx]; - if (l0->count == 0) { - return NULL; - } - return l0->slots[--l0->count]; -} - -// L0 を Unified Cache から補充（BASE を複数取り出して slots[] に積む） -// DELETED (A/B test: Unified Cache OFF is faster) -static inline void -tiny_ultra_heap_l0_refill_from_unified(TinyUltraHeap* heap, int class_idx) -{ - // Unified Cache removed - no refill possible - (void)heap; - (void)class_idx; - return; -} - -// Box UH-1: size → class の境界を 1 箇所に集約 -static inline int -tiny_ultra_heap_class_for_size(size_t size) -{ - if (__builtin_expect(size == 0 || size > tiny_get_max_size(), 0)) { - return -1; - } - - int class_idx = hak_tiny_size_to_class(size); - if (__builtin_expect(class_idx < 0 || class_idx >= TINY_NUM_CLASSES, 0)) { - return -1; - } - - return class_idx; -} - -// Box UH-2: Unified front 統合の境界 -// - hit/miss 判定と統計更新、header 書き込みまでを 1 箇所に閉じ込める。 -// DELETED (A/B test: Unified Cache OFF is faster) -static inline void* -tiny_ultra_heap_try_unified(TinyUltraHeap* heap, int class_idx) -{ - // Unified Cache removed - always return NULL - (void)heap; - (void)class_idx; - return NULL; -} - -void tiny_ultra_heap_init(void) -{ - if (__builtin_expect(g_tiny_ultra_heap.initialized, 1)) { - return; - } - - // Box 1: TinyUltraHeap 自体の init - g_tiny_ultra_heap.initialized = 1; - - // Box 2: PageLocal ビューの初期化（g_tls_slabs を alias するだけ） - for (int cls = 0; cls < TINY_NUM_CLASSES; cls++) { - g_tiny_ultra_heap.page[cls].tls = &g_tls_slabs[cls]; - g_tiny_ultra_heap.page[cls].cls = (uint8_t)cls; - g_tiny_ultra_heap.alloc_unified_hit[cls] = 0; - g_tiny_ultra_heap.alloc_unified_refill[cls] = 0; - g_tiny_ultra_heap.alloc_fallback_ultrafront[cls] = 0; - } -} - -void* tiny_ultra_heap_alloc(size_t size) -{ - tiny_ultra_heap_init(); - - // Box UH-1: size→class 変換 - int class_idx = tiny_ultra_heap_class_for_size(size); - if (__builtin_expect(class_idx < 0, 0)) { - // UltraHeap は Tiny 範囲のみ担当。範囲外は NULL で Fail-Fast。 - return NULL; - } - - TinyUltraHeap* heap = &g_tiny_ultra_heap; - - // UltraHeap L0 (実験用): ホットクラス (例: C2/C3) だけを対象に、 - // Unified Cache に到達する前にローカル L0 からの供給を試す。 - if (tiny_ultra_l0_enabled() && (class_idx == 2 || class_idx == 3)) { - void* base = tiny_ultra_heap_l0_pop(heap, class_idx); - if (!base) { - tiny_ultra_heap_l0_refill_from_unified(heap, class_idx); - base = tiny_ultra_heap_l0_pop(heap, class_idx); - } - if (base) { -#if HAKMEM_TINY_HEADER_CLASSIDX - return tiny_region_id_write_header(base, class_idx); -#else - return base; -#endif - } - } - - // Unified Cache removed (A/B test: OFF is faster) - // Always use UltraFront fallback - void* fallback = tiny_ultrafront_malloc(size); - if (fallback) { - heap->alloc_fallback_ultrafront[class_idx]++; - } - return fallback; -} - -int tiny_ultra_heap_free(void* ptr) -{ - tiny_ultra_heap_init(); - - // Free については現状の UltraFront free（Unified push）に完全委譲。 - // 将来、PageLocal の freelist 連携や page 返却をここに追加する。 - return tiny_ultrafront_free(ptr); -} - -void tiny_ultra_heap_stats_snapshot(uint64_t hit[TINY_NUM_CLASSES], - uint64_t refill[TINY_NUM_CLASSES], - uint64_t fallback[TINY_NUM_CLASSES], - int reset) -{ - tiny_ultra_heap_init(); - if (!hit || !refill || !fallback) { - return; - } - - for (int cls = 0; cls < TINY_NUM_CLASSES; cls++) { - hit[cls] = g_tiny_ultra_heap.alloc_unified_hit[cls]; - refill[cls] = g_tiny_ultra_heap.alloc_unified_refill[cls]; - fallback[cls] = g_tiny_ultra_heap.alloc_fallback_ultrafront[cls]; - } - - if (reset) { - for (int cls = 0; cls < TINY_NUM_CLASSES; cls++) { - g_tiny_ultra_heap.alloc_unified_hit[cls] = 0; - g_tiny_ultra_heap.alloc_unified_refill[cls] = 0; - g_tiny_ultra_heap.alloc_fallback_ultrafront[cls] = 0; - } - } -} - -// オプション: プロセス終了時に UltraHeap front 統計を 1 回だけダンプ（ENV で制御） -// ENV: HAKMEM_TINY_ULTRA_HEAP_DUMP=1 で有効化（デフォルト: 無効） -static void tiny_ultra_heap_dump_stats(void) __attribute__((destructor)); -static void tiny_ultra_heap_dump_stats(void) -{ - const char* dump = getenv("HAKMEM_TINY_ULTRA_HEAP_DUMP"); - if (!dump || !*dump || *dump == '0') { - return; - } - - uint64_t hit[TINY_NUM_CLASSES] = {0}; - uint64_t refill[TINY_NUM_CLASSES] = {0}; - uint64_t fallback[TINY_NUM_CLASSES] = {0}; - - tiny_ultra_heap_stats_snapshot(hit, refill, fallback, 0); - - fprintf(stderr, "[ULTRA_HEAP_STATS] class hit refill fallback\n"); - for (int c = 0; c < TINY_NUM_CLASSES; c++) { - if (hit[c] || refill[c] || fallback[c]) { - fprintf(stderr, " C%d: %llu %llu %llu\n", - c, - (unsigned long long)hit[c], - (unsigned long long)refill[c], - (unsigned long long)fallback[c]); - } - } -} - -#endif // HAKMEM_TINY_ULTRA_HEAP diff --git a/core/ultra/tiny_ultra_heap.d b/core/ultra/tiny_ultra_heap.d deleted file mode 100644 index 1f8b9931..00000000 --- a/core/ultra/tiny_ultra_heap.d +++ /dev/null @@ -1,4 +0,0 @@ -core/ultra/tiny_ultra_heap.o: core/ultra/tiny_ultra_heap.c \ - core/ultra/tiny_ultra_heap.h core/ultra/../hakmem_build_flags.h -core/ultra/tiny_ultra_heap.h: -core/ultra/../hakmem_build_flags.h: diff --git a/core/ultra/tiny_ultra_heap.h b/core/ultra/tiny_ultra_heap.h deleted file mode 100644 index 86685974..00000000 --- a/core/ultra/tiny_ultra_heap.h +++ /dev/null @@ -1,71 +0,0 @@ -// tiny_ultra_heap.h - Phase UltraFront Heap (L0 heap skeleton) -// -// 目的: -// - per-thread Tiny/Mid heap を明示化する箱。 -// - 当面は既存の Unified + Superslab 経路をそのまま使い、 -// 「heap→page→block」構造への足場だけを用意する。 -// - 将来的に PageLocal/page arena と統合していく起点。 -// -// 注意: -// - HAKMEM_TINY_ULTRA_HEAP=1 のビルドライン専用（実験用）。 -// - 既存経路を壊さないよう、当面は tiny_ultrafront_* を薄くラップするだけ。 - -#ifndef HAK_ULTRA_TINY_ULTRA_HEAP_H -#define HAK_ULTRA_TINY_ULTRA_HEAP_H - -#include "../hakmem_build_flags.h" - -#if HAKMEM_TINY_ULTRA_HEAP - -#include "../hakmem_tiny.h" // tiny_get_max_size, hak_tiny_size_to_class, TINY_NUM_CLASSES -#include "../tiny_tls.h" // TinyTLSSlab (TLS view of current slab/page) -#include "../front/tiny_ultrafront.h" // 現行 UltraFront helper（Unified+header 経路） - -// L0: Per-class PageLocal view -// - Box 的には「UltraFront が見る Tiny の page ローカル状態」の顔となる。 -// - 当面は TinyTLSSlab への薄いビュー（alias）に留め、既存実装をそのまま利用する。 -// - 将来、独立した freelist / bump ポインタを持たせる場合もここを拡張するだけで済む。 -typedef struct TinyUltraPageLocal { - TinyTLSSlab* tls; // 現行 TLS slab 構造体へのポインタ（g_tls_slabs[class] の alias） - uint8_t cls; // size class (0–7) -} TinyUltraPageLocal; - -// L0: UltraHeap 内部の per-class 小型キャッシュ -// - Box 的には「Unified Cache より手前の極小バッファ」として扱う。 -// - 実験用: C2/C3 (128B/256B) などホットクラス専用に使う想定。 -#define TINY_ULTRA_L0_CAP 64 -typedef struct TinyUltraL0 { - void* slots[TINY_ULTRA_L0_CAP]; - uint16_t count; - uint16_t _pad; -} TinyUltraL0; - -typedef struct TinyUltraHeap { - int initialized; - TinyUltraPageLocal page[TINY_NUM_CLASSES]; // C0–C7 の PageLocal ビュー - TinyUltraL0 l0[TINY_NUM_CLASSES]; // 任意クラス向け L0 キャッシュ（env で ON/OFF） - // 観察用: UltraHeap 経由 Tiny alloc の挙動をクラス別に記録 - uint64_t alloc_unified_hit[TINY_NUM_CLASSES]; // Unified hit で返せた回数 - uint64_t alloc_unified_refill[TINY_NUM_CLASSES]; // refill で Superslab から供給した回数 - uint64_t alloc_fallback_ultrafront[TINY_NUM_CLASSES]; // UltraFront 経路にフォールバックした回数 -} TinyUltraHeap; - -extern __thread TinyUltraHeap g_tiny_ultra_heap; - -// 初期化（per-thread） -void tiny_ultra_heap_init(void); - -// UltraHeap 経由の Tiny alloc/free -void* tiny_ultra_heap_alloc(size_t size); -int tiny_ultra_heap_free(void* ptr); - -// UltraHeap 統計のスナップショット取得（オプション） -// reset!=0 のとき、読み取り後に 0 にクリアする。 -void tiny_ultra_heap_stats_snapshot(uint64_t hit[TINY_NUM_CLASSES], - uint64_t refill[TINY_NUM_CLASSES], - uint64_t fallback[TINY_NUM_CLASSES], - int reset); - -#endif // HAKMEM_TINY_ULTRA_HEAP - -#endif // HAK_ULTRA_TINY_ULTRA_HEAP_H diff --git a/core/ultra/tiny_ultra_page_arena.c b/core/ultra/tiny_ultra_page_arena.c deleted file mode 100644 index 445b8b03..00000000 --- a/core/ultra/tiny_ultra_page_arena.c +++ /dev/null @@ -1,87 +0,0 @@ -#include "tiny_ultra_page_arena.h" - -#include -#include -#include - -__thread TinyUltraPageStats g_tiny_ultra_page_stats = {0}; - -// Global aggregated stats for all threads (learning layer / observer 用) -static _Atomic uint64_t g_tiny_ultra_page_global_refills[TINY_NUM_CLASSES]; - -void tiny_ultra_page_on_refill(int class_idx, SuperSlab* ss) -{ - (void)ss; // いまは統計のみ。将来 PageArena/LRU で利用予定。 - - if (class_idx < 0 || class_idx >= TINY_NUM_CLASSES) { - return; - } - - g_tiny_ultra_page_stats.superslab_refills[class_idx]++; - // 学習層から参照しやすいように、軽量なグローバル集計も行う。 - atomic_fetch_add_explicit(&g_tiny_ultra_page_global_refills[class_idx], - 1, - memory_order_relaxed); -} - -void tiny_ultra_page_stats_snapshot(uint64_t refills[TINY_NUM_CLASSES], - int reset) -{ - if (!refills) { - return; - } - - for (int cls = 0; cls < TINY_NUM_CLASSES; cls++) { - refills[cls] = g_tiny_ultra_page_stats.superslab_refills[cls]; - } - - if (reset) { - for (int cls = 0; cls < TINY_NUM_CLASSES; cls++) { - g_tiny_ultra_page_stats.superslab_refills[cls] = 0; - } - } -} - -void tiny_ultra_page_global_stats_snapshot(uint64_t refills[TINY_NUM_CLASSES], - int reset) -{ - if (!refills) { - return; - } - - for (int cls = 0; cls < TINY_NUM_CLASSES; cls++) { - refills[cls] = atomic_load_explicit(&g_tiny_ultra_page_global_refills[cls], - memory_order_relaxed); - } - - if (reset) { - for (int cls = 0; cls < TINY_NUM_CLASSES; cls++) { - atomic_store_explicit(&g_tiny_ultra_page_global_refills[cls], - 0, - memory_order_relaxed); - } - } -} - -// オプション: Ultra backend 統計をプロセス終了時に 1 回だけダンプ -// ENV: HAKMEM_TINY_ULTRA_PAGE_DUMP=1 で有効化（デフォルト: 無効） -static void tiny_ultra_page_dump_stats(void) __attribute__((destructor)); -static void tiny_ultra_page_dump_stats(void) -{ - const char* dump = getenv("HAKMEM_TINY_ULTRA_PAGE_DUMP"); - if (!dump || !*dump || *dump == '0') { - return; - } - - uint64_t refills[TINY_NUM_CLASSES] = {0}; - // 終了時ダンプではグローバル集計を使うことで、マルチスレッド環境でも全体像を掴みやすくする。 - tiny_ultra_page_global_stats_snapshot(refills, 0); - - fprintf(stderr, "[ULTRA_PAGE_STATS] class superslab_refills\n"); - for (int c = 0; c < TINY_NUM_CLASSES; c++) { - if (refills[c] != 0) { - fprintf(stderr, " C%d: %llu\n", - c, (unsigned long long)refills[c]); - } - } -} diff --git a/core/ultra/tiny_ultra_page_arena.d b/core/ultra/tiny_ultra_page_arena.d deleted file mode 100644 index cb5723da..00000000 --- a/core/ultra/tiny_ultra_page_arena.d +++ /dev/null @@ -1,24 +0,0 @@ -core/ultra/tiny_ultra_page_arena.o: core/ultra/tiny_ultra_page_arena.c \ - core/ultra/tiny_ultra_page_arena.h core/ultra/../hakmem_tiny.h \ - core/ultra/../hakmem_build_flags.h core/ultra/../hakmem_trace.h \ - core/ultra/../hakmem_tiny_mini_mag.h \ - core/ultra/../hakmem_tiny_superslab.h \ - core/ultra/../superslab/superslab_types.h \ - core/hakmem_tiny_superslab_constants.h \ - core/ultra/../superslab/superslab_inline.h \ - core/ultra/../superslab/superslab_types.h \ - core/ultra/../tiny_debug_ring.h core/ultra/../tiny_remote.h \ - core/ultra/../hakmem_tiny_superslab_constants.h -core/ultra/tiny_ultra_page_arena.h: -core/ultra/../hakmem_tiny.h: -core/ultra/../hakmem_build_flags.h: -core/ultra/../hakmem_trace.h: -core/ultra/../hakmem_tiny_mini_mag.h: -core/ultra/../hakmem_tiny_superslab.h: -core/ultra/../superslab/superslab_types.h: -core/hakmem_tiny_superslab_constants.h: -core/ultra/../superslab/superslab_inline.h: -core/ultra/../superslab/superslab_types.h: -core/ultra/../tiny_debug_ring.h: -core/ultra/../tiny_remote.h: -core/ultra/../hakmem_tiny_superslab_constants.h: diff --git a/core/ultra/tiny_ultra_page_arena.h b/core/ultra/tiny_ultra_page_arena.h deleted file mode 100644 index 43226f88..00000000 --- a/core/ultra/tiny_ultra_page_arena.h +++ /dev/null @@ -1,41 +0,0 @@ -// tiny_ultra_page_arena.h - UltraHeap backend (heap→page) telemetry box -// -// 目的: -// - UltraFront Heap (L0) から見た「page 層」の顔を 1 箇所に集約する。 -// - 現段階では Superslab refill 回数などの観察用カウンタのみを提供し、 -// 既存の shared pool / superslab 実装には手を入れない。 -// - 将来的に PageArena / LRU / prewarm のポリシーをここに集約する足場。 - -#ifndef HAK_ULTRA_TINY_ULTRA_PAGE_ARENA_H -#define HAK_ULTRA_TINY_ULTRA_PAGE_ARENA_H - -#include "../hakmem_tiny.h" // TINY_NUM_CLASSES -#include "../hakmem_tiny_superslab.h" // SuperSlab - -// Ultra backend stats (per-thread, Tiny classes only) -typedef struct TinyUltraPageStats { - // Superslab refills per class (heap→page 境界が何回発火したか) - uint64_t superslab_refills[TINY_NUM_CLASSES]; -} TinyUltraPageStats; - -// Per-thread stats instance -extern __thread TinyUltraPageStats g_tiny_ultra_page_stats; - -// heap→page 境界通知: -// - superslab_refill() が成功して TLS slab が新しい Superslab を掴んだタイミングで呼ぶ。 -// - 現状は統計を増やすだけで挙動は変えない（Fail-Fast／ポリシーは今後追加）。 -void tiny_ultra_page_on_refill(int class_idx, SuperSlab* ss); - -// 統計スナップショット取得（TinyUltraHeap からも参照可能） -// - reset!=0 のとき、読み取り後に 0 クリア。 -void tiny_ultra_page_stats_snapshot(uint64_t refills[TINY_NUM_CLASSES], - int reset); - -// Global Superslab refill stats (all threads aggregated) -// - 学習スレッドなど、TinyUltraHeap を直接触らないスレッドから利用するための箱。 -// - per-thread カウンタとは別に、軽量な _Atomic 集計を持つ。 -// reset!=0 のとき、読み取り後に 0 クリア。 -void tiny_ultra_page_global_stats_snapshot(uint64_t refills[TINY_NUM_CLASSES], - int reset); - -#endif // HAK_ULTRA_TINY_ULTRA_PAGE_ARENA_H diff --git a/hakmem.d b/hakmem.d index 9fa01f74..c18c4f5e 100644 --- a/hakmem.d +++ b/hakmem.d @@ -22,11 +22,11 @@ hakmem.o: core/hakmem.c core/hakmem.h core/hakmem_build_flags.h \ core/box/hak_kpi_util.inc.h core/box/hak_core_init.inc.h \ core/hakmem_phase7_config.h core/box/ss_hot_prewarm_box.h \ core/box/hak_alloc_api.inc.h core/box/../hakmem_tiny.h \ - core/box/../hakmem_smallmid.h core/box/hak_free_api.inc.h \ - core/hakmem_tiny_superslab.h core/box/../tiny_free_fast_v2.inc.h \ - core/box/../tiny_region_id.h core/box/../hakmem_build_flags.h \ - core/box/../hakmem_tiny_config.h core/box/../box/tls_sll_box.h \ - core/box/../box/../hakmem_tiny_config.h \ + core/box/../hakmem_smallmid.h core/box/../pool_tls.h \ + core/box/hak_free_api.inc.h core/hakmem_tiny_superslab.h \ + core/box/../tiny_free_fast_v2.inc.h core/box/../tiny_region_id.h \ + core/box/../hakmem_build_flags.h core/box/../hakmem_tiny_config.h \ + core/box/../box/tls_sll_box.h core/box/../box/../hakmem_tiny_config.h \ core/box/../box/../hakmem_build_flags.h core/box/../box/../tiny_remote.h \ core/box/../box/../tiny_region_id.h \ core/box/../box/../hakmem_tiny_integrity.h \ @@ -104,6 +104,7 @@ core/box/ss_hot_prewarm_box.h: core/box/hak_alloc_api.inc.h: core/box/../hakmem_tiny.h: core/box/../hakmem_smallmid.h: +core/box/../pool_tls.h: core/box/hak_free_api.inc.h: core/hakmem_tiny_superslab.h: core/box/../tiny_free_fast_v2.inc.h: