hakmem/core/front/tiny_ring_cache.c

// tiny_ring_cache.c - Phase 21-1: Ring cache implementation
#include "tiny_ring_cache.h"
#include <stdlib.h>
#include <string.h>

// ============================================================================
// TLS Variables (defined here, extern in header)
// ============================================================================

__thread TinyRingCache g_ring_cache_c2 = {NULL, 0, 0, 0, 0};
__thread TinyRingCache g_ring_cache_c3 = {NULL, 0, 0, 0, 0};

// ============================================================================
// Init (called at thread start, from hakmem_tiny.c)
// ============================================================================

void ring_cache_init(void) {
    if (!ring_cache_enabled()) return;

    // C2 init
    size_t cap_c2 = ring_capacity_c2();
    g_ring_cache_c2.slots = (void**)calloc(cap_c2, sizeof(void*));
    if (!g_ring_cache_c2.slots) {
#if !HAKMEM_BUILD_RELEASE
        fprintf(stderr, "[Ring-INIT] Failed to allocate C2 ring (%zu slots)\n", cap_c2);
        fflush(stderr);
#endif
        return;
    }
    g_ring_cache_c2.capacity = (uint16_t)cap_c2;
    g_ring_cache_c2.mask = (uint16_t)(cap_c2 - 1);
    g_ring_cache_c2.head = 0;
    g_ring_cache_c2.tail = 0;

    // C3 init
    size_t cap_c3 = ring_capacity_c3();
    g_ring_cache_c3.slots = (void**)calloc(cap_c3, sizeof(void*));
    if (!g_ring_cache_c3.slots) {
#if !HAKMEM_BUILD_RELEASE
        fprintf(stderr, "[Ring-INIT] Failed to allocate C3 ring (%zu slots)\n", cap_c3);
        fflush(stderr);
#endif
        // Free C2 if C3 failed
        free(g_ring_cache_c2.slots);
        g_ring_cache_c2.slots = NULL;
        return;
    }
    g_ring_cache_c3.capacity = (uint16_t)cap_c3;
    g_ring_cache_c3.mask = (uint16_t)(cap_c3 - 1);
    g_ring_cache_c3.head = 0;
    g_ring_cache_c3.tail = 0;

#if !HAKMEM_BUILD_RELEASE
    fprintf(stderr, "[Ring-INIT] C2=%zu slots (%zu bytes), C3=%zu slots (%zu bytes)\n",
            cap_c2, cap_c2 * sizeof(void*),
            cap_c3, cap_c3 * sizeof(void*));
    fflush(stderr);
#endif
}

// ============================================================================
// Shutdown (called at thread exit, optional)
// ============================================================================

void ring_cache_shutdown(void) {
    if (!ring_cache_enabled()) return;

    // Drain rings to TLS SLL before shutdown (prevent leak)
    // TODO: Implement drain logic in Phase 21-1-C

    // Free ring buffers
    if (g_ring_cache_c2.slots) {
        free(g_ring_cache_c2.slots);
        g_ring_cache_c2.slots = NULL;
    }

    if (g_ring_cache_c3.slots) {
        free(g_ring_cache_c3.slots);
        g_ring_cache_c3.slots = NULL;
    }

#if !HAKMEM_BUILD_RELEASE
    fprintf(stderr, "[Ring-SHUTDOWN] C2/C3 rings freed\n");
    fflush(stderr);
#endif
}

// ============================================================================
// Refill from TLS SLL (cascade, Phase 21-1-C)
// ============================================================================

// Refill ring from TLS SLL (one-way cascade: SLL → Ring)
// Returns: number of blocks transferred
int ring_refill_from_sll(int class_idx, int target_count) {
    if (!ring_cascade_enabled()) return 0;
    if (class_idx != 2 && class_idx != 3) return 0;

    // Forward declarations (external functions from tls_sll_box.h)
    extern int tls_sll_pop(int class_idx, void** out_ptr);
    extern int tls_sll_push(int class_idx, void* ptr, uint32_t capacity);

    int transferred = 0;

    while (transferred < target_count) {
        void* ptr = NULL;

        // Pop from TLS SLL
        if (!tls_sll_pop(class_idx, &ptr)) {
            break;  // SLL empty
        }

        // Push to Ring
        if (!ring_cache_push(class_idx, ptr)) {
            // Ring full, push back to SLL
            tls_sll_push(class_idx, ptr, (uint32_t)-1);  // Unlimited capacity
            break;
        }

        transferred++;
    }

#if !HAKMEM_BUILD_RELEASE
    if (transferred > 0) {
        fprintf(stderr, "[Ring-REFILL] C%d: %d blocks transferred from SLL to Ring\n",
                class_idx, transferred);
        fflush(stderr);
    }
#endif

    return transferred;
}

// ============================================================================
// Stats (Phase 19-1 metrics, TODO)
// ============================================================================

void ring_cache_print_stats(void) {
    if (!ring_cache_enabled()) return;

    // TODO: Add metrics tracking (Phase 21-1-E)
    // - Hit rate (Ring hits / total allocs)
    // - Miss rate (Ring empty / total allocs)
    // - Full rate (Ring full / total frees)
    // - Refill count (SLL → Ring transfers)

#if !HAKMEM_BUILD_RELEASE
    // Current occupancy
    uint16_t c2_count = (g_ring_cache_c2.tail >= g_ring_cache_c2.head)
                        ? (g_ring_cache_c2.tail - g_ring_cache_c2.head)
                        : (g_ring_cache_c2.capacity - g_ring_cache_c2.head + g_ring_cache_c2.tail);

    uint16_t c3_count = (g_ring_cache_c3.tail >= g_ring_cache_c3.head)
                        ? (g_ring_cache_c3.tail - g_ring_cache_c3.head)
                        : (g_ring_cache_c3.capacity - g_ring_cache_c3.head + g_ring_cache_c3.tail);

    fprintf(stderr, "[Ring-STATS] C2: %u/%u slots, C3: %u/%u slots\n",
            c2_count, g_ring_cache_c2.capacity,
            c3_count, g_ring_cache_c3.capacity);
    fflush(stderr);
#endif
}