03ba62df4d
Summary:
- Phase 23 Unified Cache: +30% improvement (Random Mixed 256B: 18.18M → 23.68M ops/s)
- PageFaultTelemetry: Extended to generic buckets (C0-C7, MID, L25, SSM)
- Measurement-driven decision: Mid/VM page-faults (80-100K) >> Tiny (6K) → prioritize Mid/VM optimization
Phase 23 Changes:
1. Unified Cache implementation (core/front/tiny_unified_cache.{c,h})
- Direct SuperSlab carve (TLS SLL bypass)
- Self-contained pop-or-refill pattern
- ENV: HAKMEM_TINY_UNIFIED_CACHE=1, HAKMEM_TINY_UNIFIED_C{0-7}=128
2. Fast path pruning (tiny_alloc_fast.inc.h, tiny_free_fast_v2.inc.h)
- Unified ON → direct cache access (skip all intermediate layers)
- Alloc: unified_cache_pop_or_refill() → immediate fail to slow
- Free: unified_cache_push() → fallback to SLL only if full
PageFaultTelemetry Changes:
3. Generic bucket architecture (core/box/pagefault_telemetry_box.{c,h})
- PF_BUCKET_{C0-C7, MID, L25, SSM} for domain-specific measurement
- Integration: hak_pool_try_alloc(), l25_alloc_new_run(), shared_pool_allocate_superslab_unlocked()
4. Measurement results (Random Mixed 500K / 256B):
- Tiny C2-C7: 2-33 pages, high reuse (64-3.8 touches/page)
- SSM: 512 pages (initialization footprint)
- MID/L25: 0 (unused in this workload)
- Mid/Large VM benchmarks: 80-100K page-faults (13-16x higher than Tiny)
Ring Cache Enhancements:
5. Hot Ring Cache (core/front/tiny_ring_cache.{c,h})
- ENV: HAKMEM_TINY_HOT_RING_ENABLE=1, HAKMEM_TINY_HOT_RING_C{0-7}=size
- Conditional compilation cleanup
Documentation:
6. Analysis reports
- RANDOM_MIXED_BOTTLENECK_ANALYSIS.md: Page-fault breakdown
- RANDOM_MIXED_SUMMARY.md: Phase 23 summary
- RING_CACHE_ACTIVATION_GUIDE.md: Ring cache usage
- CURRENT_TASK.md: Updated with Phase 23 results and Phase 24 plan
Next Steps (Phase 24):
- Target: Mid/VM PageArena/HotSpanBox (page-fault reduction 80-100K → 30-40K)
- Tiny SSM optimization deferred (low ROI, ~6K page-faults already optimal)
- Expected improvement: +30-50% for Mid/Large workloads
Generated with Claude Code
Co-Authored-By: Claude <noreply@anthropic.com>
80 lines
2.7 KiB
C
80 lines
2.7 KiB
C
// front_gate_classifier.h - Box FG: Pointer Classification Front Gate
|
|
//
|
|
// Purpose: Single point of truth for classifying pointers (Tiny/Pool/Mid/Large)
|
|
// Design: Heuristic-free, safe header probe + Registry lookup fallback
|
|
//
|
|
// Key Rules:
|
|
// 1. ptr-1 is read ONLY here (never elsewhere)
|
|
// 2. Header probe only when safe (same page + readable)
|
|
// 3. C7 (headerless) always identified via Registry
|
|
// 4. No 1KB alignment heuristics (eliminated false positives)
|
|
//
|
|
// Architecture:
|
|
// - Box FG (this): Classification authority
|
|
// - Box REG: SuperSlab registry (O(1) reverse lookup)
|
|
// - Box TLS: next pointer clearing for C7
|
|
//
|
|
// Performance:
|
|
// - Fast path (C0-C6 header): 5-10 cycles (unchanged)
|
|
// - Slow path (C7 REG): 50-100 cycles (rare)
|
|
// - Safety: SEGV eliminated, false positive = 0%
|
|
|
|
#ifndef FRONT_GATE_CLASSIFIER_H
|
|
#define FRONT_GATE_CLASSIFIER_H
|
|
|
|
#include <stdint.h>
|
|
#include <stddef.h>
|
|
|
|
// Forward declaration
|
|
struct SuperSlab;
|
|
|
|
// Pointer classification kinds
|
|
typedef enum {
|
|
PTR_KIND_TINY_HEADER, // C0-C6: Has 1-byte header (fast path)
|
|
PTR_KIND_TINY_HEADERLESS, // C7: Headerless 1KB blocks (REG path)
|
|
PTR_KIND_POOL_TLS, // Pool TLS 8KB-52KB
|
|
PTR_KIND_MID_LARGE, // Mid/Large allocations
|
|
PTR_KIND_UNKNOWN // Unknown/external allocation
|
|
} tiny_ptr_kind_t;
|
|
|
|
// Classification result
|
|
typedef struct {
|
|
tiny_ptr_kind_t kind; // Classification result
|
|
int class_idx; // Tiny class (0-7), or -1 if not Tiny
|
|
struct SuperSlab* ss; // SuperSlab pointer (from Registry, or NULL)
|
|
int slab_idx; // Slab index within SuperSlab (or -1)
|
|
} ptr_classification_t;
|
|
|
|
// ========== Front Gate API ==========
|
|
|
|
// Classify pointer (single point of truth)
|
|
// Returns: Classification result with kind, class_idx, SuperSlab
|
|
//
|
|
// Strategy:
|
|
// 1. Try safe header probe (C0-C6 fast path: 5-10 cycles)
|
|
// 2. Fallback to Registry lookup (C7 or header failed)
|
|
// 3. Check Pool TLS magic
|
|
// 4. Check AllocHeader (16-byte malloc/mmap)
|
|
// 5. Return UNKNOWN if all fail
|
|
//
|
|
// Safety:
|
|
// - Header probe only if: (ptr & 0xFFF) >= 1 (same page)
|
|
// - No 1KB alignment heuristics
|
|
// - Registry provides ground truth for headerless
|
|
ptr_classification_t classify_ptr(void* ptr);
|
|
|
|
// ========== Debug/Stats (optional) ==========
|
|
|
|
#if !HAKMEM_BUILD_RELEASE
|
|
// Track classification hit rates
|
|
extern __thread uint64_t g_classify_header_hit;
|
|
extern __thread uint64_t g_classify_headerless_hit;
|
|
extern __thread uint64_t g_classify_pool_hit;
|
|
extern __thread uint64_t g_classify_mid_large_hit;
|
|
extern __thread uint64_t g_classify_unknown_hit;
|
|
|
|
void front_gate_print_stats(void);
|
|
#endif
|
|
|
|
#endif // FRONT_GATE_CLASSIFIER_H
|