83bb8624f6
Summary - Fix SEGV root cause in Tiny random_mixed: TINY_REMOTE_SENTINEL leaked from Remote queue into freelist/TLS SLL. - Clear/guard sentinel at the single boundary where Remote merges to freelist. - Add minimal defense-in-depth in freelist_pop and TLS SLL pop. - Silence verbose prints behind debug gates to reduce noise in release runs. - Pool TLS: integrate Remote Queue drain at refill boundary to avoid unnecessary backend carve/OS calls when possible. - DX: strengthen build.sh with help/list/verify and add docs/BUILDING_QUICKSTART.md. Details - core/superslab/superslab_inline.h: guard head/node against TINY_REMOTE_SENTINEL; sanitize node[0] when splicing local chain; only print diagnostics when debug guard is enabled. - core/slab_handle.h: freelist_pop breaks on sentinel head (fail-fast under strict). - core/tiny_alloc_fast_inline.h: TLS SLL pop breaks on sentinel head (rare branch). - core/tiny_superslab_free.inc.h: sentinel scan log behind debug guard. - core/pool_refill.c: try pool_remote_pop_chain() before backend carve in pool_refill_and_alloc(). - core/tiny_adaptive_sizing.c: default adaptive logs off; enable via HAKMEM_ADAPTIVE_LOG=1. - build.sh: add help/list/verify; EXTRA_MAKEFLAGS passthrough; echo pinned flags. - docs/BUILDING_QUICKSTART.md: add one‑pager for targets/flags/env/perf/strace. Verification (high level) - Tiny random_mixed 10k 256/1024: SEGV resolved; runs complete. - Pool TLS 1T/4T perf: HAKMEM >= system (≈ +0.7% 1T, ≈ +2.9% 4T); syscall counts ~10–13. Known issues (to address next) - Tiny random_mixed perf is weak vs system: - 1T/500k/256: cycles/op ≈ 240 vs ~47 (≈5× slower), IPC ≈0.92, branch‑miss ≈11%. - 1T/500k/1024: cycles/op ≈ 149 vs ~53 (≈2.8× slower), IPC ≈0.82, branch‑miss ≈10.5%. - Hypothesis: frequent SuperSlab path for class7 (fast_cap=0), branchy refill/adopt, and hot-path divergence. - Proposed next steps: - Introduce fast_cap>0 for class7 (bounded TLS SLL) and a simpler batch refill. - Add env‑gated Remote Side OFF for 1T A/B (reduce side-table and guards). - Revisit likely/unlikely and unify adopt boundary sequencing (drain→bind→acquire) for Tiny.
108 lines
3.8 KiB
C
108 lines
3.8 KiB
C
// tiny_alloc_fast_inline.h - Phase 7 Task 2: Aggressive inline TLS cache access
|
|
// Purpose: Eliminate function call overhead (5-10 cycles) in hot path
|
|
// Design: Macro-based inline expansion of TLS freelist operations
|
|
// Performance: Expected +10-15% (22M → 24-25M ops/s)
|
|
|
|
#ifndef TINY_ALLOC_FAST_INLINE_H
|
|
#define TINY_ALLOC_FAST_INLINE_H
|
|
|
|
#include <stddef.h>
|
|
#include "hakmem_build_flags.h"
|
|
#include "tiny_remote.h" // for TINY_REMOTE_SENTINEL (defense-in-depth)
|
|
|
|
// External TLS variables (defined in hakmem_tiny.c)
|
|
extern __thread void* g_tls_sll_head[TINY_NUM_CLASSES];
|
|
extern __thread uint32_t g_tls_sll_count[TINY_NUM_CLASSES];
|
|
|
|
#ifndef TINY_NUM_CLASSES
|
|
#define TINY_NUM_CLASSES 8
|
|
#endif
|
|
|
|
// ========== Inline Macro: TLS Freelist Pop ==========
|
|
//
|
|
// Aggressive inline expansion of tiny_alloc_fast_pop()
|
|
// Saves: 5-10 cycles (function call overhead + register spilling)
|
|
//
|
|
// Assembly comparison (x86-64):
|
|
// Function call:
|
|
// push %rbx ; Save registers
|
|
// mov %edi, %ebx ; class_idx to %ebx
|
|
// call tiny_alloc_fast_pop ; Call (5-10 cycles overhead)
|
|
// pop %rbx ; Restore registers
|
|
// test %rax, %rax ; Check result
|
|
//
|
|
// Inline macro:
|
|
// mov g_tls_sll_head(%rdi), %rax ; Direct access (3-4 cycles)
|
|
// test %rax, %rax
|
|
// je .miss
|
|
// mov (%rax), %rdx
|
|
// mov %rdx, g_tls_sll_head(%rdi)
|
|
//
|
|
// Result: 5-10 fewer instructions, better register allocation
|
|
//
|
|
#define TINY_ALLOC_FAST_POP_INLINE(class_idx, ptr_out) do { \
|
|
void* _head = g_tls_sll_head[(class_idx)]; \
|
|
if (__builtin_expect(_head != NULL, 1)) { \
|
|
if (__builtin_expect((uintptr_t)_head == TINY_REMOTE_SENTINEL, 0)) { \
|
|
/* Break the chain defensively if sentinel leaked into TLS SLL */ \
|
|
g_tls_sll_head[(class_idx)] = NULL; \
|
|
if (g_tls_sll_count[(class_idx)] > 0) g_tls_sll_count[(class_idx)]--; \
|
|
(ptr_out) = NULL; \
|
|
} else { \
|
|
void* _next = *(void**)_head; \
|
|
g_tls_sll_head[(class_idx)] = _next; \
|
|
if (g_tls_sll_count[(class_idx)] > 0) { \
|
|
g_tls_sll_count[(class_idx)]--; \
|
|
} \
|
|
(ptr_out) = _head; \
|
|
} \
|
|
} else { \
|
|
(ptr_out) = NULL; \
|
|
} \
|
|
} while(0)
|
|
|
|
// ========== Inline Macro: TLS Freelist Push ==========
|
|
//
|
|
// Aggressive inline expansion of tiny_alloc_fast_push()
|
|
// Saves: 5-10 cycles (function call overhead)
|
|
//
|
|
// Assembly comparison:
|
|
// Function call:
|
|
// mov %rdi, %rsi ; ptr to %rsi
|
|
// mov %ebx, %edi ; class_idx to %edi
|
|
// call tiny_alloc_fast_push ; Call (5-10 cycles)
|
|
//
|
|
// Inline macro:
|
|
// mov g_tls_sll_head(%rdi), %rax ; Direct inline (2-3 cycles)
|
|
// mov %rax, (%rsi)
|
|
// mov %rsi, g_tls_sll_head(%rdi)
|
|
//
|
|
#define TINY_ALLOC_FAST_PUSH_INLINE(class_idx, ptr) do { \
|
|
*(void**)(ptr) = g_tls_sll_head[(class_idx)]; \
|
|
g_tls_sll_head[(class_idx)] = (ptr); \
|
|
g_tls_sll_count[(class_idx)]++; \
|
|
} while(0)
|
|
|
|
// ========== Performance Notes ==========
|
|
//
|
|
// Benchmark results (expected):
|
|
// - Random Mixed 128B: 21M → 23M ops/s (+10%)
|
|
// - Random Mixed 256B: 19M → 22M ops/s (+15%)
|
|
// - Larson 1T: 2.7M → 3.0M ops/s (+11%)
|
|
//
|
|
// Key optimizations:
|
|
// 1. No function call overhead (save 5-10 cycles)
|
|
// 2. Better register allocation (inline knows full context)
|
|
// 3. No stack frame setup/teardown
|
|
// 4. Compiler can optimize across macro boundaries
|
|
//
|
|
// Trade-offs:
|
|
// 1. Code size: +100-200 bytes (each call site expanded)
|
|
// 2. Debug visibility: Macros harder to step through
|
|
// 3. Maintenance: Changes must be kept in sync with function version
|
|
//
|
|
// Recommendation: Use inline macros for CRITICAL hot paths only
|
|
// (alloc/free fast path), keep functions for diagnostics/debugging
|
|
|
|
#endif // TINY_ALLOC_FAST_INLINE_H
|