hakmem/core/front/tiny_ring_cache.c

// tiny_ring_cache.c - Phase 21-1: Ring cache implementation
#include "tiny_ring_cache.h"
#include "../box/tls_sll_box.h"  // For tls_sll_pop/push (Phase 21-1-C refill)
#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};
__thread TinyRingCache g_ring_cache_c5 = {NULL, 0, 0, 0, 0};

// ============================================================================
// Metrics (Phase 21-1-E, optional for Phase 21-1-C)
// ============================================================================

#if !HAKMEM_BUILD_RELEASE
__thread uint64_t g_ring_cache_hit[8] = {0};
__thread uint64_t g_ring_cache_miss[8] = {0};
__thread uint64_t g_ring_cache_push[8] = {0};
__thread uint64_t g_ring_cache_full[8] = {0};
__thread uint64_t g_ring_cache_refill[8] = {0};
#endif

// ============================================================================
// 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;

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

#if !HAKMEM_BUILD_RELEASE
    fprintf(stderr, "[Ring-INIT] C2=%zu slots (%zu bytes), C3=%zu slots (%zu bytes), C5=%zu slots (%zu bytes)\n",
            cap_c2, cap_c2 * sizeof(void*),
            cap_c3, cap_c3 * sizeof(void*),
            cap_c5, cap_c5 * 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 (g_ring_cache_c5.slots) {
        free(g_ring_cache_c5.slots);
        g_ring_cache_c5.slots = NULL;
    }

#if !HAKMEM_BUILD_RELEASE
    fprintf(stderr, "[Ring-SHUTDOWN] C2/C3/C5 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;

    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) {
        g_ring_cache_refill[class_idx]++;  // Count refill operations
        fprintf(stderr, "[Ring-REFILL] C%d: %d blocks transferred from SLL to Ring\n",
                class_idx, transferred);
        fflush(stderr);
    }
#endif

    return transferred;
}

// ============================================================================
// Stats (Phase 21-1-C/E metrics)
// ============================================================================

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

#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, "\n[Ring-STATS] Ring Cache Metrics (C2/C3):\n");
    fprintf(stderr, "  C2: %u/%u slots occupied\n", c2_count, g_ring_cache_c2.capacity);
    fprintf(stderr, "  C3: %u/%u slots occupied\n", c3_count, g_ring_cache_c3.capacity);

    // Metrics summary (C2/C3 only)
    for (int c = 2; c <= 3; c++) {
        uint64_t total_allocs = g_ring_cache_hit[c] + g_ring_cache_miss[c];
        uint64_t total_frees = g_ring_cache_push[c] + g_ring_cache_full[c];
        double hit_rate = (total_allocs > 0) ? (100.0 * g_ring_cache_hit[c] / total_allocs) : 0.0;
        double full_rate = (total_frees > 0) ? (100.0 * g_ring_cache_full[c] / total_frees) : 0.0;

        if (total_allocs > 0 || total_frees > 0) {
            fprintf(stderr, "  C%d: hit=%llu miss=%llu (%.1f%% hit), push=%llu full=%llu (%.1f%% full), refill=%llu\n",
                    c,
                    (unsigned long long)g_ring_cache_hit[c],
                    (unsigned long long)g_ring_cache_miss[c],
                    hit_rate,
                    (unsigned long long)g_ring_cache_push[c],
                    (unsigned long long)g_ring_cache_full[c],
                    full_rate,
                    (unsigned long long)g_ring_cache_refill[c]);
        }
    }
    fflush(stderr);
#endif
}