hakmem/core/box/ss_slab_meta_box.h

#ifndef SS_SLAB_META_BOX_H
#define SS_SLAB_META_BOX_H

// ============================================================================
// Box: SlabMeta Access Layer (Phase 3d-A)
// ============================================================================
// Purpose: Encapsulate SuperSlab metadata field access
// Boundary: SuperSlab internal layout (slabs[] array)
// Benefits:
//   - Single point of change for future layout optimizations
//   - Enables Hot/Cold split without touching call sites
//   - Supports A/B testing via compile-time flags
//
// Design: Thin inline wrappers (zero overhead, unchanged behavior)
// ============================================================================

#include "../superslab/superslab_types.h"
#include "slab_freelist_atomic.h"  // Phase 1: Atomic freelist accessor

// ----------------------------------------------------------------------------
// HOT field accessors (frequent access on alloc/free paths)
// ----------------------------------------------------------------------------

// Get freelist pointer (HOT field) - ATOMIC for MT safety
static inline void* ss_slab_meta_freelist_get(SuperSlab* ss, int slab_idx) {
    return slab_freelist_load_relaxed(&ss->slabs[slab_idx]);
}

// Set freelist pointer (HOT field) - ATOMIC for MT safety
static inline void ss_slab_meta_freelist_set(SuperSlab* ss, int slab_idx, void* ptr) {
    slab_freelist_store_relaxed(&ss->slabs[slab_idx], ptr);
}

// Get used count (HOT field) - ATOMIC for MT safety
static inline uint16_t ss_slab_meta_used_get(SuperSlab* ss, int slab_idx) {
    return atomic_load_explicit(&ss->slabs[slab_idx].used, memory_order_relaxed);
}

// Set used count (HOT field) - ATOMIC for MT safety
static inline void ss_slab_meta_used_set(SuperSlab* ss, int slab_idx, uint16_t val) {
    atomic_store_explicit(&ss->slabs[slab_idx].used, val, memory_order_relaxed);
}

// Increment used count (HOT field, common operation) - ATOMIC for MT safety
static inline void ss_slab_meta_used_inc(SuperSlab* ss, int slab_idx) {
    atomic_fetch_add_explicit(&ss->slabs[slab_idx].used, 1, memory_order_relaxed);
}

// Decrement used count (HOT field, common operation) - ATOMIC for MT safety
static inline void ss_slab_meta_used_dec(SuperSlab* ss, int slab_idx) {
    atomic_fetch_sub_explicit(&ss->slabs[slab_idx].used, 1, memory_order_relaxed);
}

// Get capacity (HOT field)
static inline uint16_t ss_slab_meta_capacity_get(SuperSlab* ss, int slab_idx) {
    return ss->slabs[slab_idx].capacity;
}

// Set capacity (HOT field, set once at init)
static inline void ss_slab_meta_capacity_set(SuperSlab* ss, int slab_idx, uint16_t val) {
    ss->slabs[slab_idx].capacity = val;
}

// ----------------------------------------------------------------------------
// COLD field accessors (rare access: init, debug, stats)
// ----------------------------------------------------------------------------

// Get class_idx (COLD field)
static inline uint8_t ss_slab_meta_class_idx_get(SuperSlab* ss, int slab_idx) {
    return ss->slabs[slab_idx].class_idx;
}

// Set class_idx (COLD field, set once at init)
static inline void ss_slab_meta_class_idx_set(SuperSlab* ss, int slab_idx, uint8_t val) {
    ss->slabs[slab_idx].class_idx = val;
}

// Get carved (COLD field)
static inline uint8_t ss_slab_meta_carved_get(SuperSlab* ss, int slab_idx) {
    return ss->slabs[slab_idx].carved;
}

// Set carved (COLD field)
static inline void ss_slab_meta_carved_set(SuperSlab* ss, int slab_idx, uint8_t val) {
    ss->slabs[slab_idx].carved = val;
}

// Get owner_tid_low (COLD field, debug only)
static inline uint8_t ss_slab_meta_owner_tid_low_get(SuperSlab* ss, int slab_idx) {
    return ss->slabs[slab_idx].owner_tid_low;
}

// Set owner_tid_low (COLD field, debug only)
static inline void ss_slab_meta_owner_tid_low_set(SuperSlab* ss, int slab_idx, uint8_t val) {
    ss->slabs[slab_idx].owner_tid_low = val;
}

// ----------------------------------------------------------------------------
// Legacy direct pointer access (for gradual migration)
// ----------------------------------------------------------------------------

// Get pointer to TinySlabMeta (for code that needs direct struct access)
// TODO Phase 3d-B: Migrate all users to field-specific accessors above
static inline TinySlabMeta* ss_slab_meta_ptr(SuperSlab* ss, int slab_idx) {
    return &ss->slabs[slab_idx];
}

#endif // SS_SLAB_META_BOX_H