From 28784591325c30e3fd9558f3cf4b740976636070 Mon Sep 17 00:00:00 2001 From: "Moe Charm (CI)" Date: Fri, 21 Nov 2025 03:20:42 +0900 Subject: [PATCH] Refactor: Extract 4 safe Box modules from hakmem_tiny.c (-73% total reduction) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Conservative refactoring with Task-sensei's safety analysis. ## Changes **hakmem_tiny.c**: 616 → 562 lines (-54 lines, -9% this phase) **Total reduction**: 2081 → 562 lines (-1519 lines, -73% cumulative) 🏆 ## Extracted Modules (4 new LOW-risk boxes) 9. **ss_active_box** (6 lines) - ss_active_add() - atomic add to active counter - ss_active_inc() - atomic increment active counter - Pure utility functions, no dependencies - Risk: LOW 10. **eventq_box** (32 lines) - hak_thread_id16() - thread ID compression - eventq_push_ex() - event queue push with sampling - Intelligence/telemetry helpers - Risk: LOW 11. **sll_cap_box** (12 lines) - sll_cap_for_class() - SLL capacity policy - Hot classes get multiplier × mag_cap - Cold classes get mag_cap / 2 - Risk: LOW 12. **ultra_batch_box** (20 lines) - g_ultra_batch_override[] - batch size overrides - g_ultra_sll_cap_override[] - SLL capacity overrides - ultra_batch_for_class() - batch size policy - Risk: LOW ## Cumulative Progress (12 boxes total) **Phase 1** (5 boxes): 2081 → 995 lines (-52%) **Phase 2** (3 boxes): 995 → 616 lines (-38%) **Phase 3** (4 boxes): 616 → 562 lines (-9%) **All 12 boxes**: 1. config_box (211 lines) 2. publish_box (419 lines) 3. globals_box (256 lines) 4. phase6_wrappers_box (122 lines) 5. ace_guard_box (100 lines) 6. tls_state_box (224 lines) 7. legacy_slow_box (96 lines) 8. slab_lookup_box (77 lines) 9. ss_active_box (6 lines) ✨ 10. eventq_box (32 lines) ✨ 11. sll_cap_box (12 lines) ✨ 12. ultra_batch_box (20 lines) ✨ **Total extracted**: 1,575 lines across 12 coherent modules **Remaining core**: 562 lines (highly focused) ## Safety Approach - Task-sensei performed deep dependency analysis - Extracted only LOW-risk candidates - All dependencies verified at compile time - Forward declarations already present - No circular dependencies - Build tested after each extraction ✅ 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude --- core/hakmem_tiny.c | 78 +++++----------------------- core/hakmem_tiny_eventq_box.inc | 32 ++++++++++++ core/hakmem_tiny_sll_cap_box.inc | 12 +++++ core/hakmem_tiny_ss_active_box.inc | 6 +++ core/hakmem_tiny_ultra_batch_box.inc | 20 +++++++ 5 files changed, 82 insertions(+), 66 deletions(-) create mode 100644 core/hakmem_tiny_eventq_box.inc create mode 100644 core/hakmem_tiny_sll_cap_box.inc create mode 100644 core/hakmem_tiny_ss_active_box.inc create mode 100644 core/hakmem_tiny_ultra_batch_box.inc diff --git a/core/hakmem_tiny.c b/core/hakmem_tiny.c index 378d8264..82d34df0 100644 --- a/core/hakmem_tiny.c +++ b/core/hakmem_tiny.c @@ -80,12 +80,10 @@ static void tiny_remote_drain_locked(struct TinySlab* slab); __attribute__((always_inline)) static inline void* hak_tiny_alloc_wrapper(int class_idx); // Helpers for SuperSlab active block accounting (atomic, saturating dec) -void ss_active_add(SuperSlab* ss, uint32_t n) { - atomic_fetch_add_explicit(&ss->total_active_blocks, n, memory_order_relaxed); -} -static inline __attribute__((always_inline)) void ss_active_inc(SuperSlab* ss) { - atomic_fetch_add_explicit(&ss->total_active_blocks, 1u, memory_order_relaxed); -} + +// SuperSlab Active Counter Helpers - EXTRACTED to hakmem_tiny_ss_active_box.inc +#include "hakmem_tiny_ss_active_box.inc" + // EXTRACTED: ss_active_dec_one() moved to hakmem_tiny_superslab.h (Phase 2C-2) // Front refill count global config (declare before init.inc uses them) @@ -240,38 +238,10 @@ _Atomic uint32_t g_frontend_fill_target[TINY_NUM_CLASSES]; static inline int ultra_batch_for_class(int class_idx); enum { HAK_TIER_SLL=1, HAK_TIER_MAG=2, HAK_TIER_SLAB=3, HAK_TIER_SUPER=4, HAK_TIER_FRONT=5 }; -static inline uint16_t hak_thread_id16(void) { - // best-effort compress cached thread id to 16 bits - uint32_t tid = tiny_self_u32(); - return (uint16_t)(tid ^ (tid >> 16)); -} -static inline void eventq_push_ex(int class_idx, uint32_t size, uint8_t tier, uint8_t flags, - uint32_t site_id, uint16_t lat_bucket) { - (void)flags; +// Event Queue & Telemetry Helpers - EXTRACTED to hakmem_tiny_eventq_box.inc +#include "hakmem_tiny_eventq_box.inc" - (void)lat_bucket; - (void)site_id; - - if (!g_int_engine) return; - // Lightweight sampling: if mask set, log 1 out of 2^N - unsigned m = g_int_sample_mask; - if (m != 0) { - unsigned x = g_tls_ev_seq++; - if ((x & m) != 0) return; - } - uint32_t t = atomic_fetch_add_explicit(&g_ev_tail, 1u, memory_order_relaxed); - AllocEvent ev; - ev.ts_ns = g_int_event_ts ? hak_now_ns() : 0; - ev.size = size; - ev.site_id = 0; // keep minimal - ev.latency_bucket = 0; - ev.tier_hit = tier; - ev.flags = 0; - ev.class_idx = (uint16_t)class_idx; - ev.thread_id = 0; - g_ev_ring[t & EVENTQ_MASK] = ev; // best-effort overwrite on overflow -} // Background refill workers and intelligence engine #include "hakmem_tiny_background.inc" @@ -344,18 +314,10 @@ static inline void* hak_tiny_alloc_superslab_try_fast(int class_idx) { // SLL capacity policy: for hot tiny classes (0..3), allow larger SLL up to multiplier * mag_cap // for >=4 keep current conservative half (to limit footprint). -static inline uint32_t sll_cap_for_class(int class_idx, uint32_t mag_cap) { - // Phase12: g_sll_cap_override は非推奨。ここでは無視して通常capを返す。 - uint32_t cap = mag_cap; - if (class_idx <= 3) { - uint32_t mult = (g_sll_multiplier > 0 ? (uint32_t)g_sll_multiplier : 1u); - uint64_t want = (uint64_t)cap * (uint64_t)mult; - if (want > (uint64_t)TINY_TLS_MAG_CAP) cap = TINY_TLS_MAG_CAP; else cap = (uint32_t)want; - } else if (class_idx >= 4) { - cap = (mag_cap > 1u ? (mag_cap / 2u) : 1u); - } - return cap; -} + +// SLL Capacity Policy - EXTRACTED to hakmem_tiny_sll_cap_box.inc +#include "hakmem_tiny_sll_cap_box.inc" + // ============================================================================ // EXTRACTED TO hakmem_tiny_refill.inc.h (Phase 2D-1) @@ -366,25 +328,9 @@ static inline uint32_t sll_cap_for_class(int class_idx, uint32_t mag_cap) { 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 (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}; +// Ultra-Mode Batch Configuration - EXTRACTED to hakmem_tiny_ultra_batch_box.inc +#include "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（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 - } -} // ============================================================================ // EXTRACTED TO hakmem_tiny_refill.inc.h (Phase 2D-1) diff --git a/core/hakmem_tiny_eventq_box.inc b/core/hakmem_tiny_eventq_box.inc new file mode 100644 index 00000000..5929c3f1 --- /dev/null +++ b/core/hakmem_tiny_eventq_box.inc @@ -0,0 +1,32 @@ +static inline uint16_t hak_thread_id16(void) { + // best-effort compress cached thread id to 16 bits + uint32_t tid = tiny_self_u32(); + return (uint16_t)(tid ^ (tid >> 16)); +} + +static inline void eventq_push_ex(int class_idx, uint32_t size, uint8_t tier, uint8_t flags, + uint32_t site_id, uint16_t lat_bucket) { + (void)flags; + + (void)lat_bucket; + (void)site_id; + + if (!g_int_engine) return; + // Lightweight sampling: if mask set, log 1 out of 2^N + unsigned m = g_int_sample_mask; + if (m != 0) { + unsigned x = g_tls_ev_seq++; + if ((x & m) != 0) return; + } + uint32_t t = atomic_fetch_add_explicit(&g_ev_tail, 1u, memory_order_relaxed); + AllocEvent ev; + ev.ts_ns = g_int_event_ts ? hak_now_ns() : 0; + ev.size = size; + ev.site_id = 0; // keep minimal + ev.latency_bucket = 0; + ev.tier_hit = tier; + ev.flags = 0; + ev.class_idx = (uint16_t)class_idx; + ev.thread_id = 0; + g_ev_ring[t & EVENTQ_MASK] = ev; // best-effort overwrite on overflow +} diff --git a/core/hakmem_tiny_sll_cap_box.inc b/core/hakmem_tiny_sll_cap_box.inc new file mode 100644 index 00000000..9a2a6ba4 --- /dev/null +++ b/core/hakmem_tiny_sll_cap_box.inc @@ -0,0 +1,12 @@ +static inline uint32_t sll_cap_for_class(int class_idx, uint32_t mag_cap) { + // Phase12: g_sll_cap_override は非推奨。ここでは無視して通常capを返す。 + uint32_t cap = mag_cap; + if (class_idx <= 3) { + uint32_t mult = (g_sll_multiplier > 0 ? (uint32_t)g_sll_multiplier : 1u); + uint64_t want = (uint64_t)cap * (uint64_t)mult; + if (want > (uint64_t)TINY_TLS_MAG_CAP) cap = TINY_TLS_MAG_CAP; else cap = (uint32_t)want; + } else if (class_idx >= 4) { + cap = (mag_cap > 1u ? (mag_cap / 2u) : 1u); + } + return cap; +} diff --git a/core/hakmem_tiny_ss_active_box.inc b/core/hakmem_tiny_ss_active_box.inc new file mode 100644 index 00000000..6e08c886 --- /dev/null +++ b/core/hakmem_tiny_ss_active_box.inc @@ -0,0 +1,6 @@ +void ss_active_add(SuperSlab* ss, uint32_t n) { + atomic_fetch_add_explicit(&ss->total_active_blocks, n, memory_order_relaxed); +} +static inline __attribute__((always_inline)) void ss_active_inc(SuperSlab* ss) { + atomic_fetch_add_explicit(&ss->total_active_blocks, 1u, memory_order_relaxed); +} diff --git a/core/hakmem_tiny_ultra_batch_box.inc b/core/hakmem_tiny_ultra_batch_box.inc new file mode 100644 index 00000000..ad2c691d --- /dev/null +++ b/core/hakmem_tiny_ultra_batch_box.inc @@ -0,0 +1,20 @@ + +// 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 + } +}