03df05ec75
## Summary
Implemented Phase 12 Shared SuperSlab Pool (mimalloc-style) to address
SuperSlab allocation churn (877 SuperSlabs → 100-200 target).
## Implementation (ChatGPT + Claude)
1. **Metadata changes** (superslab_types.h):
- Added class_idx to TinySlabMeta (per-slab dynamic class)
- Removed size_class from SuperSlab (no longer per-SuperSlab)
- Changed owner_tid (16-bit) → owner_tid_low (8-bit)
2. **Shared Pool** (hakmem_shared_pool.{h,c}):
- Global pool shared by all size classes
- shared_pool_acquire_slab() - Get free slab for class_idx
- shared_pool_release_slab() - Return slab when empty
- Per-class hints for fast path optimization
3. **Integration** (23 files modified):
- Updated all ss->size_class → meta->class_idx
- Updated all meta->owner_tid → meta->owner_tid_low
- superslab_refill() now uses shared pool
- Free path releases empty slabs back to pool
4. **Build system** (Makefile):
- Added hakmem_shared_pool.o to OBJS_BASE and TINY_BENCH_OBJS_BASE
## Status: ⚠️ Build OK, Runtime CRASH
**Build**: ✅ SUCCESS
- All 23 files compile without errors
- Only warnings: superslab_allocate type mismatch (legacy code)
**Runtime**: ❌ SEGFAULT
- Crash location: sll_refill_small_from_ss()
- Exit code: 139 (SIGSEGV)
- Test case: ./bench_random_mixed_hakmem 1000 256 42
## Known Issues
1. **SEGFAULT in refill path** - Likely shared_pool_acquire_slab() issue
2. **Legacy superslab_allocate()** still exists (type mismatch warning)
3. **Remaining TODOs** from design doc:
- SuperSlab physical layout integration
- slab_handle.h cleanup
- Remove old per-class head implementation
## Next Steps
1. Debug SEGFAULT (gdb backtrace shows sll_refill_small_from_ss)
2. Fix shared_pool_acquire_slab() or superslab_init_slab()
3. Basic functionality test (1K → 100K iterations)
4. Measure SuperSlab count reduction (877 → 100-200)
5. Performance benchmark (+650-860% expected)
## Files Changed (25 files)
core/box/free_local_box.c
core/box/free_remote_box.c
core/box/front_gate_classifier.c
core/hakmem_super_registry.c
core/hakmem_tiny.c
core/hakmem_tiny_bg_spill.c
core/hakmem_tiny_free.inc
core/hakmem_tiny_lifecycle.inc
core/hakmem_tiny_magazine.c
core/hakmem_tiny_query.c
core/hakmem_tiny_refill.inc.h
core/hakmem_tiny_superslab.c
core/hakmem_tiny_superslab.h
core/hakmem_tiny_tls_ops.h
core/slab_handle.h
core/superslab/superslab_inline.h
core/superslab/superslab_types.h
core/tiny_debug.h
core/tiny_free_fast.inc.h
core/tiny_free_magazine.inc.h
core/tiny_remote.c
core/tiny_superslab_alloc.inc.h
core/tiny_superslab_free.inc.h
Makefile
## New Files (3 files)
PHASE12_SHARED_SUPERSLAB_POOL_DESIGN.md
core/hakmem_shared_pool.c
core/hakmem_shared_pool.h
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude <noreply@anthropic.com>
Co-Authored-By: ChatGPT <chatgpt@openai.com>
58 lines
1.9 KiB
C
58 lines
1.9 KiB
C
#pragma once
|
|
|
|
#include <stdint.h>
|
|
#include <pthread.h>
|
|
#include <stdatomic.h>
|
|
#include "superslab/superslab_types.h"
|
|
|
|
// Shared SuperSlab Pool (Phase 12-2 skeleton)
|
|
// Multiple tiny size classes share a global set of SuperSlab instances.
|
|
// This header exposes the minimal API used by refill/free hot paths in Phase 12.
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
typedef struct SharedSuperSlabPool {
|
|
SuperSlab** slabs; // Dynamic array of SuperSlab*
|
|
uint32_t capacity; // Allocated entries in slabs[]
|
|
uint32_t total_count; // Total SuperSlabs ever allocated (<= capacity)
|
|
uint32_t active_count; // SuperSlabs that have >0 active slabs
|
|
|
|
pthread_mutex_t alloc_lock; // Protects pool metadata and grow/scan operations
|
|
|
|
// Per-class hints: last known SuperSlab with a free slab for that class.
|
|
// Read lock-free (best-effort), updated under alloc_lock.
|
|
SuperSlab* class_hints[TINY_NUM_CLASSES_SS];
|
|
|
|
// LRU cache integration hooks (Phase 9/12, optional for now)
|
|
SuperSlab* lru_head;
|
|
SuperSlab* lru_tail;
|
|
uint32_t lru_count;
|
|
} SharedSuperSlabPool;
|
|
|
|
// Global singleton
|
|
extern SharedSuperSlabPool g_shared_pool;
|
|
|
|
// Initialize shared pool (idempotent, thread-safe wrt multiple callers on startup paths)
|
|
void shared_pool_init(void);
|
|
|
|
// Get/allocate a SuperSlab registered in the pool.
|
|
// Returns non-NULL on success, NULL on failure.
|
|
SuperSlab* shared_pool_acquire_superslab(void);
|
|
|
|
// Acquire a slab for class_idx from shared pool.
|
|
// On success:
|
|
// *ss_out = SuperSlab containing slab
|
|
// *slab_idx_out = slab index [0, SLABS_PER_SUPERSLAB_MAX)
|
|
// Returns 0 on success, non-zero on failure.
|
|
int shared_pool_acquire_slab(int class_idx, SuperSlab** ss_out, int* slab_idx_out);
|
|
|
|
// Release an empty slab back to pool (mark as unassigned).
|
|
// Caller must ensure TinySlabMeta.used == 0.
|
|
void shared_pool_release_slab(SuperSlab* ss, int slab_idx);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|