ra8_io_blockdev_cache.c

Go to the documentation of this file.

 
#include "ra8_io_blockdev_cache.h"
 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_io_blockdev.h"
#include "ra8_io_blockdev_backend.h"

static const char* const s_tag = "ra8_io_blockdev_cache";

RA8_INTERNAL
RA8_INTERNAL static uint32_t internal_cache_find(const ra8_io_blockdev_cache_state_t* st,
                                                 uint32_t                             lba)
{
  for (uint32_t i = 0; i < st->n_slots; ++i) {
    if (!st->slots[i].valid) {
      continue;
    }
    if (st->slots[i].lba == lba) {
      return i;
    }
  }
  return st->n_slots;
}

RA8_INTERNAL
RA8_INTERNAL static uint32_t internal_cache_pick_victim(const ra8_io_blockdev_cache_state_t* st)
{
  uint32_t best = 0;
  for (uint32_t i = 0; i < st->n_slots; ++i) {
    if (!st->slots[i].valid) {
      return i;
    }
    if (st->slots[i].last_use < st->slots[best].last_use) {
      best = i;
    }
  }
  return best;
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t
internal_cache_read_block(ra8_io_blockdev_cache_state_t* st, uint32_t lba, uint8_t* dst)
{
  st->clock++;
  const uint32_t hit  = internal_cache_find(st, lba);
  const size_t   span = (size_t)k_ra8_io_block_size_bytes;
  if (hit != st->n_slots) {
    st->hits++;
    (void)memcpy(dst, &st->data[(size_t)hit * span], span);
    st->slots[hit].last_use = st->clock;
    return k_ra8_ok;
  }
  st->misses++;
  const uint32_t v = internal_cache_pick_victim(st);
  RA8_RETURN_ON_ERROR(ra8_io_blockdev_read(st->under, lba, 1, &st->data[(size_t)v * span]),
                      s_tag,
                      "backend read");
  st->slots[v].lba      = lba;
  st->slots[v].valid    = true;
  st->slots[v].last_use = st->clock;
  (void)memcpy(dst, &st->data[(size_t)v * span], span);
  return k_ra8_ok;
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t
internal_cache_write_block(ra8_io_blockdev_cache_state_t* st, uint32_t lba, const uint8_t* src)
{
  RA8_RETURN_ON_ERROR(ra8_io_blockdev_write(st->under, lba, 1, src), s_tag, "backend write");
  st->clock++;
  const size_t span = (size_t)k_ra8_io_block_size_bytes;
  uint32_t     idx  = internal_cache_find(st, lba);
  if (idx == st->n_slots) {
    idx = internal_cache_pick_victim(st);
  }
  (void)memcpy(&st->data[(size_t)idx * span], src, span);
  st->slots[idx].lba      = lba;
  st->slots[idx].valid    = true;
  st->slots[idx].last_use = st->clock;
  return k_ra8_ok;
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t
internal_cache_read(void* ctx, uint32_t lba, uint32_t count, uint8_t* buf)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag, "ctx must not be nullptr");
  RA8_CHECK_NULL_PTR(buf, s_tag, "buf must not be nullptr");
  ra8_io_blockdev_cache_state_t* st   = (ra8_io_blockdev_cache_state_t*)ctx;
  const size_t                   span = (size_t)k_ra8_io_block_size_bytes;
  for (uint32_t i = 0; i < count; ++i) {
    RA8_RETURN_ON_ERROR(internal_cache_read_block(st, lba + i, &buf[(size_t)i * span]),
                        s_tag,
                        "read block");
  }
  return k_ra8_ok;
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t
internal_cache_write(void* ctx, uint32_t lba, uint32_t count, const uint8_t* buf)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag, "ctx must not be nullptr");
  RA8_CHECK_NULL_PTR(buf, s_tag, "buf must not be nullptr");
  ra8_io_blockdev_cache_state_t* st   = (ra8_io_blockdev_cache_state_t*)ctx;
  const size_t                   span = (size_t)k_ra8_io_block_size_bytes;
  for (uint32_t i = 0; i < count; ++i) {
    RA8_RETURN_ON_ERROR(internal_cache_write_block(st, lba + i, &buf[(size_t)i * span]),
                        s_tag,
                        "write block");
  }
  return k_ra8_ok;
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t internal_cache_erase(void* ctx, uint32_t lba, uint32_t count)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag, "ctx must not be nullptr");
  ra8_io_blockdev_cache_state_t* st = (ra8_io_blockdev_cache_state_t*)ctx;
  RA8_RETURN_ON_ERROR(ra8_io_blockdev_erase(st->under, lba, count), s_tag, "backend erase");
  const uint32_t end = lba + count;
  for (uint32_t i = 0; i < st->n_slots; ++i) {
    if (!st->slots[i].valid) {
      continue;
    }
    if (st->slots[i].lba < lba) {
      continue;
    }
    if (st->slots[i].lba >= end) {
      continue;
    }
    st->slots[i].valid = false;
  }
  return k_ra8_ok;
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t internal_cache_get_caps(const void* ctx, ra8_io_blockdev_caps_t* out)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag, "ctx must not be nullptr");
  RA8_CHECK_NULL_PTR(out, s_tag, "out must not be nullptr");
  const ra8_io_blockdev_cache_state_t* st = (const ra8_io_blockdev_cache_state_t*)ctx;
  return ra8_io_blockdev_get_caps(st->under, out);
}

RA8_INTERNAL
RA8_INTERNAL static ra8_err_t internal_cache_sync(void* ctx)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag, "ctx must not be nullptr");
  const ra8_io_blockdev_cache_state_t* st = (const ra8_io_blockdev_cache_state_t*)ctx;
  return ra8_io_blockdev_sync(st->under);
}

static const ra8_io_blockdev_iface_t s_cache_iface = {
  .read     = internal_cache_read,
  .write    = internal_cache_write,
  .erase    = internal_cache_erase,
  .get_caps = internal_cache_get_caps,
  .sync     = internal_cache_sync,
};

RA8_INTERNAL
RA8_INTERNAL static void internal_cache_state_init(ra8_io_blockdev_cache_state_t* state,
                                                   const ra8_io_blockdev_t*       under,
                                                   uint8_t*                       data,
                                                   ra8_io_blockdev_cache_slot_t*  slots,
                                                   uint32_t                       n_slots)
{
  state->under   = under;
  state->data    = data;
  state->slots   = slots;
  state->n_slots = n_slots;
  state->clock   = 0;
  state->hits    = 0;
  state->misses  = 0;
}

RA8_INTERNAL
RA8_INTERNAL static void internal_cache_reset_slots(ra8_io_blockdev_cache_slot_t* slots,
                                                    uint32_t                      n_slots)
{
  for (uint32_t i = 0; i < n_slots; ++i) {
    slots[i].valid    = false;
    slots[i].lba      = 0;
    slots[i].last_use = 0;
  }
}
 
ra8_err_t ra8_io_blockdev_cache_init(ra8_io_blockdev_t*             bd,
                                     ra8_io_blockdev_cache_state_t* state,
                                     const ra8_io_blockdev_t*       under,
                                     uint8_t*                       data,
                                     ra8_io_blockdev_cache_slot_t*  slots,
                                     uint32_t                       n_slots)
{
  RA8_CHECK_NULL_PTR(bd, s_tag, "bd must not be nullptr");
  RA8_CHECK_NULL_PTR(state, s_tag, "state must not be nullptr");
  RA8_CHECK_NULL_PTR(under, s_tag, "under must not be nullptr");
  RA8_CHECK_NULL_PTR(data, s_tag, "data must not be nullptr");
  RA8_CHECK_NULL_PTR(slots, s_tag, "slots must not be nullptr");
  if (n_slots == 0U) {
    return k_ra8_err_invalid_size;
  }
  internal_cache_state_init(state, under, data, slots, n_slots);
  internal_cache_reset_slots(slots, n_slots);
  bd->iface = &s_cache_iface;
  bd->ctx   = state;
  return k_ra8_ok;
}
 
ra8_err_t ra8_io_blockdev_cache_stats(const ra8_io_blockdev_cache_state_t* state,
                                      uint32_t*                            out_hits,
                                      uint32_t*                            out_misses)
{
  RA8_CHECK_NULL_PTR(state, s_tag, "state must not be nullptr");
  if (out_hits != nullptr) {
    *out_hits = state->hits;
  }
  if (out_misses != nullptr) {
    *out_misses = state->misses;
  }
  return k_ra8_ok;
}