lru.c

Go to the documentation of this file.

#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include <uthash.h>
 
#include <aaruformat.h>
 
// LRU cache using uthash with native integer keys.
// Based on uthash LRU example by Jehiah Czebotar 2011 (public domain).
// Rewritten to use HASH_FIND/HASH_ADD with uint64_t keys directly,
// eliminating all string conversion, malloc, and snprintf overhead
// from the hot path.

static void drop_entry(struct CacheHeader *cache, struct CacheEntry *entry)
{
    HASH_DELETE(hh, cache->cache, entry);
 
    cache->cur_bytes -= entry->size;
 
    if(cache->free_func && entry->value) cache->free_func(entry->value);
 
    free(entry);
}

void *find_in_cache_uint64(struct CacheHeader *cache, const uint64_t key)
{
    struct CacheEntry *entry = NULL;
    HASH_FIND(hh, cache->cache, &key, sizeof(uint64_t), entry);
    if(entry)
    {
        // Remove and re-add to move to front of insertion-order list (LRU refresh).
        HASH_DELETE(hh, cache->cache, entry);
        HASH_ADD(hh, cache->cache, key, sizeof(uint64_t), entry);
        return entry->value;
    }
    return NULL;
}

void add_to_cache_uint64(struct CacheHeader *cache, const uint64_t key, void *value, const size_t size)
{
    struct CacheEntry *entry = NULL;
 
    // Replace an existing entry for this key. A blind HASH_ADD would leave the old entry in the
    // table unreachable by HASH_FIND, and its value alive until the whole cache is freed.
    HASH_FIND(hh, cache->cache, &key, sizeof(uint64_t), entry);
 
    if(entry)
    {
        cache->cur_bytes -= entry->size;
 
        if(cache->free_func && entry->value && entry->value != value) cache->free_func(entry->value);
 
        HASH_DELETE(hh, cache->cache, entry);
    }
    else
    {
        entry = malloc(sizeof(struct CacheEntry));
        if(!entry) return;
    }
 
    entry->key   = key;
    entry->value = value;
    entry->size  = size;
    HASH_ADD(hh, cache->cache, key, sizeof(uint64_t), entry);
    cache->cur_bytes += size;
 
    if(cache->max_bytes == 0) return;
 
    // Evict least recently used entries until back under budget. Never evict the entry just
    // inserted: the caller still uses that pointer after this returns.
    while(cache->cur_bytes > cache->max_bytes && HASH_COUNT(cache->cache) > 1)
    {
        struct CacheEntry *oldest = cache->cache;
 
        if(oldest == NULL || oldest == entry) break;
 
        drop_entry(cache, oldest);
    }
}

void free_cache(struct CacheHeader *cache)
{
    struct CacheEntry *entry, *tmp;
 
    if(!cache || !cache->cache) return;
 
    HASH_ITER(hh, cache->cache, entry, tmp) { drop_entry(cache, entry); }
 
    cache->cache     = NULL;
    cache->cur_bytes = 0;
}