ra8_vmem.c

Go to the documentation of this file.

 
#include "ra8_vmem.h"
 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_keycache.h"

static const char* const s_tag = "ra8_vmem";

typedef enum : uint32_t {
  k_vmem_hash_mul_obj  = 2654435761U, 
  k_vmem_hash_mul_page = 40503U,      
} ra8_vmem_hash_const_t;

typedef enum : uint8_t {
  k_vmem_off_shift = 32U, 
} ra8_vmem_shift_const_t;

RA8_INTERNAL
RA8_INTERNAL static uint32_t internal_vmem_hash(const void* key, uint32_t key_bytes, void* ctx)
{
  (void)key_bytes;
  (void)ctx;
  const ra8_vmem_key_t* k  = (const ra8_vmem_key_t*)key;
  const uint32_t        lo = (uint32_t)k->offset;
  const uint32_t        hi = (uint32_t)(k->offset >> (uint64_t)k_vmem_off_shift);
  return (k->object_id * (uint32_t)k_vmem_hash_mul_obj) ^
         ((lo ^ hi) * (uint32_t)k_vmem_hash_mul_page);
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t
internal_vmem_fill(void* ctx, const void* key, uint8_t* cell, uint32_t cell_bytes, void* user)
{
  (void)user;
  ra8_vmem_t*           vm = (ra8_vmem_t*)ctx;
  const ra8_vmem_key_t* k  = (const ra8_vmem_key_t*)key;
  return vm->cfg.loader(vm->cfg.loader_ctx, k->object_id, k->offset, cell, cell_bytes);
}
 
ra8_err_t ra8_vmem_init(ra8_vmem_t* vm, const ra8_vmem_cfg_t* cfg)
{
  RA8_CHECK_NULL_PTR(vm, s_tag, "vm must not be nullptr");
  RA8_CHECK_NULL_PTR(cfg, s_tag, "cfg must not be nullptr");
  (void)memset(vm, 0, sizeof(*vm));
  vm->cfg                 = *cfg;
  ra8_keycache_cfg_t kcfg = {};
  kcfg.cell_mem           = cfg->frame_mem;
  kcfg.cell_bytes         = cfg->frame_bytes;
  kcfg.cell_count         = cfg->frame_count;
  kcfg.key_mem            = (uint8_t*)cfg->keys;
  kcfg.key_bytes          = (uint32_t)sizeof(ra8_vmem_key_t);
  kcfg.user_mem           = nullptr;
  kcfg.user_bytes         = 0U;
  kcfg.meta               = cfg->meta;
  kcfg.buckets            = cfg->buckets;
  kcfg.bucket_count       = cfg->bucket_count;
  kcfg.render             = internal_vmem_fill;
  kcfg.render_ctx         = vm;
  kcfg.evict              = k_ra8_keycache_evict_slru;
  kcfg.protected_pct      = cfg->protected_pct;
  kcfg.hash               = internal_vmem_hash;
  kcfg.hash_ctx           = nullptr;
  const ra8_err_t err     = ra8_keycache_init(&vm->kc, &kcfg);
  if (err != k_ra8_ok) {
    return err;
  }
  vm->protected_cap = vm->kc.protected_cap;
  return k_ra8_ok;
}
 
ra8_err_t ra8_vmem_get(ra8_vmem_t* vm, uint32_t object_id, uint64_t offset, void** out_page)
{
  RA8_CHECK_NULL_PTR(vm, s_tag, "vm must not be nullptr");
  RA8_CHECK_NULL_PTR(out_page, s_tag, "out_page must not be nullptr");
  const uint32_t fb       = vm->cfg.frame_bytes;
  ra8_vmem_key_t k        = {};
  k.object_id             = object_id;
  k.offset                = offset - (offset % (uint64_t)fb);
  ra8_keycache_view_t v   = {};
  const ra8_err_t     err = ra8_keycache_get(&vm->kc, &k, &v);
  if (err != k_ra8_ok) {
    return err;
  }
  *out_page = v.data;
  return k_ra8_ok;
}
 
ra8_err_t ra8_vmem_put(ra8_vmem_t* vm, void* page)
{
  RA8_CHECK_NULL_PTR(vm, s_tag, "vm must not be nullptr");
  RA8_CHECK_NULL_PTR(page, s_tag, "page must not be nullptr");
  return ra8_keycache_put(&vm->kc, (const uint8_t*)page);
}
 
ra8_err_t ra8_vmem_prefetch(ra8_vmem_t* vm, uint32_t object_id, uint64_t offset)
{
  RA8_CHECK_NULL_PTR(vm, s_tag, "vm must not be nullptr");
  void*           page     = nullptr;
  const ra8_err_t load_err = ra8_vmem_get(vm, object_id, offset, &page);
  if (load_err != k_ra8_ok) {
    return load_err;
  }
  /* Drop the pin now: the page is resident but evictable (SLRU probationary), so
   * a wrong read-ahead guess ages out before hot data. */
  return ra8_vmem_put(vm, page);
}
 
ra8_err_t ra8_vmem_stats(const ra8_vmem_t* vm,
                         uint32_t*         out_hits,
                         uint32_t*         out_misses,
                         uint32_t*         out_evictions)
{
  RA8_CHECK_NULL_PTR(vm, s_tag, "vm must not be nullptr");
  if (vm->cfg.frame_mem == nullptr) {
    return k_ra8_err_invalid_state;
  }
  return ra8_keycache_stats(&vm->kc, out_hits, out_misses, out_evictions);
}