tomoaki/hakmem
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
418 Commits 2 Branches 0 Tags
cd3280eee71475211c1b718bcaa9dcc7dd71b48e
Commit Graph

7 Commits

Author SHA1 Message Date
Moe Charm (CI)
984cca41ef P0 Optimization: Shared Pool fast path with O(1) metadata lookup 
Performance Results:
- Throughput: 2.66M ops/s → 3.8M ops/s (+43% improvement)
- sp_meta_find_or_create: O(N) linear scan → O(1) direct pointer
- Stage 2 metadata scan: 100% → 10-20% (80-90% reduction via hints)

Core Optimizations:

1. O(1) Metadata Lookup (superslab_types.h)
   - Added `shared_meta` pointer field to SuperSlab struct
   - Eliminates O(N) linear search through ss_metadata[] array
   - First access: O(N) scan + cache | Subsequent: O(1) direct return

2. sp_meta_find_or_create Fast Path (hakmem_shared_pool.c)
   - Check cached ss->shared_meta first before linear scan
   - Cache pointer after successful linear scan for future lookups
   - Reduces 7.8% CPU hotspot to near-zero for hot paths

3. Stage 2 Class Hints Fast Path (hakmem_shared_pool_acquire.c)
   - Try class_hints[class_idx] FIRST before full metadata scan
   - Uses O(1) ss->shared_meta lookup for hint validation
   - __builtin_expect() for branch prediction optimization
   - 80-90% of acquire calls now skip full metadata scan

4. Proper Initialization (ss_allocation_box.c)
   - Initialize shared_meta = NULL in superslab_allocate()
   - Ensures correct NULL-check semantics for new SuperSlabs

Additional Improvements:
- Updated ptr_trace and debug ring for release build efficiency
- Enhanced ENV variable documentation and analysis
- Added learner_env_box.h for configuration management
- Various Box optimizations for reduced overhead

Thread Safety:
- All atomic operations use correct memory ordering
- shared_meta cached under mutex protection
- Lock-free Stage 2 uses proper CAS with acquire/release semantics

Testing:
- Benchmark: 1M iterations, 3.8M ops/s stable
- Build: Clean compile RELEASE=0 and RELEASE=1
- No crashes, memory leaks, or correctness issues

Next Optimization Candidates:
- P1: Per-SuperSlab free slot bitmap for O(1) slot claiming
- P2: Reduce Stage 2 critical section size
- P3: Page pre-faulting (MAP_POPULATE)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
 2025-12-04 16:21:54 +09:00
Moe Charm (CI)
d78baf41ce Phase 3: Remove mincore() syscall completely 
Problem:
- mincore() was already disabled by default (DISABLE_MINCORE=1)
- Phase 1b/2 registry-based validation made mincore obsolete
- Dead code (~60 lines) remained with complex #ifdef guards

Solution:
Complete removal of mincore() syscall and related infrastructure:

1. Makefile:
   - Removed DISABLE_MINCORE configuration (lines 167-177)
   - Added Phase 3 comment documenting removal rationale

2. core/box/hak_free_api.inc.h:
   - Removed ~60 lines of mincore logic with TLS page cache
   - Simplified to: int is_mapped = 1;
   - Added comprehensive history comment

3. core/box/external_guard_box.h:
   - Simplified external_guard_is_mapped() from 20 lines to 4 lines
   - Always returns 1 (assume mapped)
   - Added Phase 3 comment

Safety:
Trust internal metadata for all validation:
- SuperSlab registry: validates Tiny allocations (Phase 1b/2)
- AllocHeader: validates Mid/Large allocations
- FrontGate classifier: routes external allocations

Testing:
✓ Build: Clean compilation (no warnings)
✓ Stability: 100/100 test iterations passed (0% crash rate)
✓ Performance: No regression (mincore already disabled)

History:
- Phase 9: Used mincore() for safety
- 2025-11-14: Added DISABLE_MINCORE flag (+10.3% perf improvement)
- Phase 1b/2: Registry-based validation (0% crash rate)
- Phase 3: Dead code cleanup (this commit)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
 2025-11-29 09:04:32 +09:00
Moe Charm (CI)
4f2bcb7d32 Refactor: Phase 2 Box化 - SuperSlab Lookup Box with multiple contract levels 
Purpose: Formalize SuperSlab lookup responsibilities with clear safety guarantees

Evolution:
- Phase 12: UNSAFE mask+dereference (5-10 cycles) → 12% crash rate
- Phase 1b: SAFE registry lookup (50-100 cycles) → 0% crash rate
- Phase 2: Box化 - multiple contracts (UNSAFE/SAFE/GUARDED)

Box Pattern Benefits:
1. Clear Contracts: Each API documents preconditions and guarantees
2. Multiple Levels: Choose speed vs safety based on context
3. Future-Proof: Enables optimizations without breaking existing code

API Design:
- ss_lookup_unsafe(): 5-10 cycles, requires validated pointer (internal use only)
- ss_lookup_safe(): 50-100 cycles, works with arbitrary pointers (recommended)
- ss_lookup_guarded(): 100-200 cycles, adds integrity checks (debug only)
- ss_fast_lookup(): Backward compatible (→ ss_lookup_safe)

Implementation:
- Created core/box/superslab_lookup_box.h with full contract documentation
- Integrated into core/superslab/superslab_inline.h
- ss_lookup_safe() implemented as macro to avoid circular dependency
- ss_lookup_guarded() only available in debug builds
- Removed conflicting extern declarations from 3 locations

Testing:
- Build: Success (all warnings resolved)
- Crash rate: 0% (50/50 iterations passed)
- Backward compatibility: Maintained via ss_fast_lookup() macro

Future Optimization Opportunities (documented in Box):
- Phase 2.1: Hybrid lookup (try UNSAFE first, fallback to SAFE)
- Phase 2.2: Per-thread cache (1-2 cycles hit rate)
- Phase 2.3: Hardware-assisted validation (PAC/CPUID)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
 2025-11-29 08:44:29 +09:00
Moe Charm (CI)
38552c3f39 Phase 3d-A: SlabMeta Box boundary - Encapsulate SuperSlab metadata access 
ChatGPT-guided Box theory refactoring (Phase A: Boundary only).

Changes:
- Created ss_slab_meta_box.h with 15 inline accessor functions
  - HOT fields (8): freelist, used, capacity (fast path)
  - COLD fields (6): class_idx, carved, owner_tid_low (init/debug)
  - Legacy (1): ss_slab_meta_ptr() for atomic ops
- Migrated 14 direct slabs[] access sites across 6 files
  - hakmem_shared_pool.c (4 sites)
  - tiny_free_fast_v2.inc.h (1 site)
  - hakmem_tiny.c (3 sites)
  - external_guard_box.h (1 site)
  - hakmem_tiny_lifecycle.inc (1 site)
  - ss_allocation_box.c (4 sites)

Architecture:
- Zero overhead (static inline wrappers)
- Single point of change for future layout optimizations
- Enables Hot/Cold split (Phase C) without touching call sites
- A/B testing support via compile-time flags

Verification:
- Build: ✅ Success (no errors)
- Stability: ✅ All sizes pass (128B-1KB, 22-24M ops/s)
- Behavior: Unchanged (thin wrapper, no logic changes)

Next: Phase B (TLS Cache Merge, +12-18% expected)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
 2025-11-20 02:01:52 +09:00
Moe Charm (CI)
6199e9ba01 Phase 15 Box Separation: Fix wrapper domain check to prevent BenchMeta→CoreAlloc violation 
Fix free() wrapper unconditionally routing ALL pointers to hak_free_at(),
causing Box boundary violations (BenchMeta slots[] entering CoreAlloc).

Solution: Add domain check in wrapper using 1-byte header inspection:
  - Non-page-aligned: Check ptr-1 for HEADER_MAGIC (0xa0/0xb0)
    - Hakmem Tiny → route to hak_free_at()
    - External/BenchMeta → route to __libc_free()
  - Page-aligned: Full classification (cannot safely check header)

Results:
  - 99.29% BenchMeta properly freed via __libc_free() ✅
  - 0.71% page-aligned fallthrough → ExternalGuard leak (acceptable)
  - No crashes (100K/500K iterations stable)
  - Performance: 15.3M ops/s (maintained)

Changes:
  - core/box/hak_wrappers.inc.h: Domain check logic (lines 227-256)
  - core/box/external_guard_box.h: Conservative leak prevention
  - core/hakmem_super_registry.h: SUPER_MAX_PROBE 8→32
  - PHASE15_WRAPPER_DOMAIN_CHECK_FIX.md: Comprehensive analysis

Root cause identified by user: LD_PRELOAD intercepts __libc_free(),
wrapper needs defense-in-depth to maintain Box boundaries.
 2025-11-16 00:38:29 +09:00
Moe Charm (CI)
d378ee11a0 Phase 15: Box BenchMeta separation + ExternalGuard debug + investigation report 
- Implement Box BenchMeta pattern in bench_random_mixed.c (BENCH_META_CALLOC/FREE)
- Add enhanced debug logging to external_guard_box.h (caller tracking, FG classification)
- Document investigation in PHASE15_BUG_ANALYSIS.md

Issue: Page-aligned MIDCAND pointer not in SuperSlab registry → ExternalGuard → crash
Hypothesis: May be pre-existing SuperSlab bug (not Phase 15-specific)
Next: Test in Phase 14-C to verify
 2025-11-15 23:00:21 +09:00
Moe Charm (CI)
cef99b311d Phase 15: Box Separation (partial) - Box headers completed, routing deferred 
**Status**: Box FG V2 + ExternalGuard 実装完了、hak_free_at routing は Phase 14-C に revert

**Files Created**:
1. core/box/front_gate_v2.h (98 lines)
   - Ultra-fast 1-byte header classification (TINY/POOL/MIDCAND/EXTERNAL)
   - Performance: 2-5 cycles
   - Same-page guard added (防御的プログラミング)

2. core/box/external_guard_box.h (146 lines)
   - ENV-controlled mincore safety check
   - HAKMEM_EXTERNAL_GUARD_MINCORE=0/1 (default: OFF)
   - Uses __libc_free() to avoid infinite loop

**Routing**:
- hak_free_at reverted to Phase 14-C (classify_ptr-based, stable)
- Phase 15 routing caused SEGV on page-aligned pointers

**Performance**:
- Phase 14-C (mincore ON): 16.5M ops/s (stable)
- mincore: 841 calls/100K iterations
- mincore OFF: SEGV (unsafe AllocHeader deref)

**Next Steps** (deferred):
- Mid/Large/C7 registry consolidation
- AllocHeader safety validation
- ExternalGuard integration

**Recommendation**: Stick with Phase 14-C for now
- mincore overhead acceptable (~1.9ms / 100K)
- Focus on other bottlenecks (TLS SLL, SuperSlab churn)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
 2025-11-15 22:08:51 +09:00