Phase 21-1-A: Ring cache 基本実装 - Array-based TLS cache (C2/C3)
## Summary Phase 21-1-A の基本実装完了。Ring buffer ベースの TLS cache を C2/C3 （33-128B）専用に実装。ポインタチェイス削減で +15-20% 性能向上を目指す。 ## Implementation **Files Created**: - `core/front/tiny_ring_cache.h` - Ring cache API, ENV control - `core/front/tiny_ring_cache.c` - Ring cache implementation **Makefile Integration**: - Added `core/front/tiny_ring_cache.o` to OBJS_BASE - Added `core/front/tiny_ring_cache_shared.o` to SHARED_OBJS - Added `core/front/tiny_ring_cache.o` to BENCH_HAKMEM_OBJS_BASE ## Design (Task 先生調査結果 + ChatGPT フィードバック) **Ring Buffer Structure**: - C2/C3 専用（hot classes, 33-128B） - Default 128 slots (power-of-2, ENV で 64/128/256 A/B 可能) - Ultra-fast pop/push (1-2 instructions, array access) - Fast modulo via mask (capacity - 1) **Hierarchy** (Option 4: UltraHot 置き換え): ``` Ring (L0, C2/C3 専用) → HeapV2 (L1, fallback) → TLS SLL (L2) → SuperSlab (L3) ``` **Rationale**: - UltraHot の C3 問題（5.8% hit rate）を根本解決 - Phase 19-3 の +12.9%（UltraHot 除去）を維持 - Ring サイズ（128）>> UltraHot（4）→ hit rate 大幅向上期待 **Performance Goal**: - Pointer chasing: TLS SLL 1 回 → Ring 0 回 - Memory access: 3 → 2 回 - Cache locality: 配列（連続メモリ）vs linked list - Expected: +15-20% (54.4M → 62-65M ops/s) ## ENV Variables ```bash HAKMEM_TINY_HOT_RING_ENABLE=1 # Ring 有効化 (default: 0) HAKMEM_TINY_HOT_RING_C2=128 # C2 サイズ (default: 128) HAKMEM_TINY_HOT_RING_C3=128 # C3 サイズ (default: 128) HAKMEM_TINY_HOT_RING_CASCADE=1 # SLL → Ring refill (default: 0) ``` ## Implementation Status Phase 21-1-A: ✅ **COMPLETE** - Ring buffer data structure - TLS variables - ENV control (enable/capacity) - Power-of-2 capacity (fast modulo) - Ultra-fast pop/push inline functions - Refill from SLL (scaffold) - Init/shutdown/stats (scaffold) - Makefile integration - Compile success Phase 21-1-B: ⏳ **NEXT** - Alloc/Free 統合 Phase 21-1-C: ⏳ **PENDING** - Refill/Cascade 実装 Phase 21-1-D: ⏳ **PENDING** - A/B テスト ## Next Steps 1. Alloc path 統合 (`core/tiny_alloc_fast.inc.h`) 2. Free path 統合 (`core/tiny_free_fast_v2.inc.h`) 3. Init call from `hakmem_tiny.c` 4. A/B test: Ring vs UltraHot vs Baseline 🎯 Target: 62-65M ops/s (+15-20% vs 54.4M baseline) 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Moe Charm (CI)
189
core/front/tiny_ring_cache.h
Normal file
189
core/front/tiny_ring_cache.h
Normal file
@ -0,0 +1,189 @@
|
||||
// tiny_ring_cache.h - Phase 21-1: Array-based hot cache (C2/C3 only)
|
||||
//
|
||||
// Goal: Eliminate pointer chasing in TLS SLL by using ring buffer
|
||||
// Target: +15-20% performance (54.4M → 62-65M ops/s)
|
||||
//
|
||||
// Design (ChatGPT feedback):
|
||||
// - Ring → SLL → SuperSlab (3-layer hierarchy)
|
||||
// - Ring size: 128 slots (ENV: 64/128/256 A/B test)
|
||||
// - C2/C3 only (hot classes, 33-128B)
|
||||
// - Replaces UltraHot (Phase 19-3: +12.9% by removing UltraHot)
|
||||
//
|
||||
// Performance:
|
||||
// - Alloc: 1-2 instructions (array access, no pointer chasing)
|
||||
// - Free: 1-2 instructions (array write, no pointer chasing)
|
||||
// - vs TLS SLL: 3 mem accesses → 2 mem accesses, 1 cache miss → 0
|
||||
//
|
||||
// ENV Variables:
|
||||
// HAKMEM_TINY_HOT_RING_ENABLE=1 # Enable Ring cache (default: 0)
|
||||
// HAKMEM_TINY_HOT_RING_C2=128 # C2 ring size (default: 128)
|
||||
// HAKMEM_TINY_HOT_RING_C3=128 # C3 ring size (default: 128)
|
||||
// HAKMEM_TINY_HOT_RING_CASCADE=1 # Enable SLL → Ring refill (default: 0)
|
||||
|
||||
#ifndef HAK_FRONT_TINY_RING_CACHE_H
|
||||
#define HAK_FRONT_TINY_RING_CACHE_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include "../hakmem_build_flags.h"
|
||||
|
||||
// ============================================================================
|
||||
// Ring Buffer Structure
|
||||
// ============================================================================
|
||||
|
||||
typedef struct {
|
||||
void** slots; // Dynamic array (allocated at init, power-of-2 size)
|
||||
uint16_t head; // Pop index (consumer)
|
||||
uint16_t tail; // Push index (producer)
|
||||
uint16_t capacity; // Ring size (power of 2 for fast modulo: & (capacity-1))
|
||||
uint16_t mask; // Capacity - 1 (for fast modulo)
|
||||
} TinyRingCache;
|
||||
|
||||
// ============================================================================
|
||||
// External TLS Variables (defined in hakmem_tiny.c)
|
||||
// ============================================================================
|
||||
|
||||
extern __thread TinyRingCache g_ring_cache_c2;
|
||||
extern __thread TinyRingCache g_ring_cache_c3;
|
||||
|
||||
// ============================================================================
|
||||
// ENV Control (cached, lazy init)
|
||||
// ============================================================================
|
||||
|
||||
// Enable flag (default: 0, OFF)
|
||||
static inline int ring_cache_enabled(void) {
|
||||
static int g_enable = -1;
|
||||
if (__builtin_expect(g_enable == -1, 0)) {
|
||||
const char* e = getenv("HAKMEM_TINY_HOT_RING_ENABLE");
|
||||
g_enable = (e && *e && *e != '0') ? 1 : 0;
|
||||
#if !HAKMEM_BUILD_RELEASE
|
||||
if (g_enable) {
|
||||
fprintf(stderr, "[Ring-INIT] ring_cache_enabled() = %d\n", g_enable);
|
||||
fflush(stderr);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
return g_enable;
|
||||
}
|
||||
|
||||
// C2 capacity (default: 128)
|
||||
static inline size_t ring_capacity_c2(void) {
|
||||
static size_t g_cap = 0;
|
||||
if (__builtin_expect(g_cap == 0, 0)) {
|
||||
const char* e = getenv("HAKMEM_TINY_HOT_RING_C2");
|
||||
g_cap = (e && *e) ? (size_t)atoi(e) : 128; // Default: 128
|
||||
|
||||
// Round up to power of 2 (for fast modulo)
|
||||
if (g_cap < 32) g_cap = 32;
|
||||
if (g_cap > 256) g_cap = 256;
|
||||
|
||||
// Ensure power of 2
|
||||
size_t pow2 = 32;
|
||||
while (pow2 < g_cap) pow2 *= 2;
|
||||
g_cap = pow2;
|
||||
|
||||
#if !HAKMEM_BUILD_RELEASE
|
||||
fprintf(stderr, "[Ring-INIT] C2 capacity = %zu (power of 2)\n", g_cap);
|
||||
fflush(stderr);
|
||||
#endif
|
||||
}
|
||||
return g_cap;
|
||||
}
|
||||
|
||||
// C3 capacity (default: 128)
|
||||
static inline size_t ring_capacity_c3(void) {
|
||||
static size_t g_cap = 0;
|
||||
if (__builtin_expect(g_cap == 0, 0)) {
|
||||
const char* e = getenv("HAKMEM_TINY_HOT_RING_C3");
|
||||
g_cap = (e && *e) ? (size_t)atoi(e) : 128; // Default: 128
|
||||
|
||||
// Round up to power of 2
|
||||
if (g_cap < 32) g_cap = 32;
|
||||
if (g_cap > 256) g_cap = 256;
|
||||
|
||||
size_t pow2 = 32;
|
||||
while (pow2 < g_cap) pow2 *= 2;
|
||||
g_cap = pow2;
|
||||
|
||||
#if !HAKMEM_BUILD_RELEASE
|
||||
fprintf(stderr, "[Ring-INIT] C3 capacity = %zu (power of 2)\n", g_cap);
|
||||
fflush(stderr);
|
||||
#endif
|
||||
}
|
||||
return g_cap;
|
||||
}
|
||||
|
||||
// Cascade enable flag (default: 0, OFF)
|
||||
static inline int ring_cascade_enabled(void) {
|
||||
static int g_enable = -1;
|
||||
if (__builtin_expect(g_enable == -1, 0)) {
|
||||
const char* e = getenv("HAKMEM_TINY_HOT_RING_CASCADE");
|
||||
g_enable = (e && *e && *e != '0') ? 1 : 0;
|
||||
#if !HAKMEM_BUILD_RELEASE
|
||||
if (g_enable) {
|
||||
fprintf(stderr, "[Ring-INIT] ring_cascade_enabled() = %d\n", g_enable);
|
||||
fflush(stderr);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
return g_enable;
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Ultra-Fast Pop/Push (1-2 instructions)
|
||||
// ============================================================================
|
||||
|
||||
// Pop from ring (alloc fast path)
|
||||
// Returns: BASE pointer (caller must convert to USER with +1)
|
||||
static inline void* ring_cache_pop(int class_idx) {
|
||||
TinyRingCache* ring = (class_idx == 2) ? &g_ring_cache_c2 : &g_ring_cache_c3;
|
||||
|
||||
// Empty check
|
||||
if (__builtin_expect(ring->head == ring->tail, 0)) {
|
||||
return NULL; // Empty
|
||||
}
|
||||
|
||||
// Pop from head (consumer)
|
||||
void* base = ring->slots[ring->head];
|
||||
ring->head = (ring->head + 1) & ring->mask; // Fast modulo (power of 2)
|
||||
|
||||
return base; // Return BASE pointer
|
||||
}
|
||||
|
||||
// Push to ring (free fast path)
|
||||
// Input: BASE pointer (caller must pass BASE, not USER)
|
||||
// Returns: 1=SUCCESS, 0=FULL
|
||||
static inline int ring_cache_push(int class_idx, void* base) {
|
||||
TinyRingCache* ring = (class_idx == 2) ? &g_ring_cache_c2 : &g_ring_cache_c3;
|
||||
|
||||
uint16_t next_tail = (ring->tail + 1) & ring->mask;
|
||||
|
||||
// Full check (leave 1 slot empty to distinguish full/empty)
|
||||
if (__builtin_expect(next_tail == ring->head, 0)) {
|
||||
return 0; // Full
|
||||
}
|
||||
|
||||
// Push to tail (producer)
|
||||
ring->slots[ring->tail] = base;
|
||||
ring->tail = next_tail;
|
||||
|
||||
return 1; // SUCCESS
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Refill from TLS SLL (cascade, Phase 21-1-C)
|
||||
// ============================================================================
|
||||
|
||||
// Forward declaration (defined in tiny_ring_cache.c)
|
||||
int ring_refill_from_sll(int class_idx, int target_count);
|
||||
|
||||
// ============================================================================
|
||||
// Init/Shutdown (called from hakmem_tiny.c)
|
||||
// ============================================================================
|
||||
|
||||
void ring_cache_init(void);
|
||||
void ring_cache_shutdown(void);
|
||||
void ring_cache_print_stats(void);
|
||||
|
||||
#endif // HAK_FRONT_TINY_RING_CACHE_H
|
||||
Reference in New Issue
Block a user