cache_store_demo.c

Go to the documentation of this file.

 
#include "cache_store_demo.h"
 
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_cache_store.h"
#include "ra8_check.h"
#include "ra8_err.h"

typedef enum : uint32_t {
  k_demo_key_cover  = 0xC07E5001U, 
  k_demo_key_tile_a = 0x11E0A002U, 
  k_demo_key_tile_b = 0x11E0B003U, 
  k_demo_key_tile_c = 0x11E0C004U, 
  k_demo_key_tile_d = 0x11E0D005U, 
} demo_key_t;

typedef enum : uint32_t {
  k_demo_len_cover  = 1400U, 
  k_demo_len_tile_a = 300U,  
  k_demo_len_tile_b = 900U,  
  k_demo_len_tile_c = 1100U, 
  k_demo_len_tile_d = 400U,  
} demo_len_t;

typedef enum : uint8_t {
  k_demo_seed_cover  = 0x40U, 
  k_demo_seed_tile_a = 0x11U, 
  k_demo_seed_tile_b = 0x22U, 
  k_demo_seed_tile_c = 0x33U, 
  k_demo_seed_tile_d = 0x55U, 
} demo_seed_t;

typedef enum : uint32_t {
  k_demo_survivors = 4U, 
} demo_count_t;

RA8_INTERNAL static void internal_demo_fill(uint8_t* buf, uint32_t len, uint8_t seed)
{
  if (buf == nullptr) {
    return;
  }
  if (len == 0U) {
    return;
  }
  for (uint32_t i = 0U; i < len; i++) {
    buf[i] = (uint8_t)(seed + (uint8_t)i);
  }
}

RA8_INTERNAL static bool internal_demo_matches(const uint8_t* buf, uint32_t len, uint8_t seed)
{
  if (buf == nullptr) {
    return false;
  }
  if (len == 0U) {
    return true;
  }
  for (uint32_t i = 0U; i < len; i++) {
    if (buf[i] != (uint8_t)(seed + (uint8_t)i)) {
      return false;
    }
  }
  return true;
}

RA8_INTERNAL static ra8_err_t
internal_demo_build_cfg(const cache_store_demo_cfg_t* in, bool format, ra8_cache_store_cfg_t* out)
{
  RA8_CHECK_NULL_PTR(in, "rcs_demo", "cfg is NULL");
  RA8_CHECK_NULL_PTR(out, "rcs_demo", "out cfg is NULL");
  *out = (ra8_cache_store_cfg_t){
    .nor_flash         = in->nor_flash,
    .nor_driver_init   = in->nor_driver_init,
    .name              = "rcs_demo",
    .index             = in->index,
    .staging           = in->staging,
    .staging_bytes     = in->staging_bytes,
    .logical_sectors   = in->logical_sectors,
    .index_cap         = in->index_cap,
    .overprovision_pct = 0U, /* 0 => the store's default GC headroom margin. */
    .format            = format,
  };
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_demo_put_and_verify(ra8_cache_store_t*            st,
                                                           uint32_t                      key,
                                                           uint8_t                       seed,
                                                           uint32_t                      len,
                                                           const cache_store_demo_cfg_t* cfg)
{
  RA8_CHECK_NULL_PTR(st, "rcs_demo", "store is NULL");
  RA8_CHECK_NULL_PTR(cfg, "rcs_demo", "cfg is NULL");
  if (len > cfg->scratch_bytes) {
    return k_ra8_err_invalid_size;
  }
  internal_demo_fill(cfg->scratch, len, seed);
  ra8_err_t rc = ra8_cache_store_put(st, key, cfg->scratch, len);
  if (rc != k_ra8_ok) {
    return rc;
  }
  ra8_cache_store_reader_t rd = {};
  rc                          = ra8_cache_store_get(st, key, &rd);
  if (rc != k_ra8_ok) {
    return rc;
  }
  if (rd.byte_len != len) {
    return k_ra8_err_invalid_state;
  }
  (void)memset(cfg->scratch, 0, (size_t)len);
  rc = ra8_cache_store_read(&rd, 0U, cfg->scratch, len);
  if (rc != k_ra8_ok) {
    return rc;
  }
  if (!internal_demo_matches(cfg->scratch, len, seed)) {
    return k_ra8_err_invalid_state;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_demo_get_and_verify(const ra8_cache_store_t*      st,
                                                           uint32_t                      key,
                                                           uint8_t                       seed,
                                                           uint32_t                      len,
                                                           const cache_store_demo_cfg_t* cfg)
{
  RA8_CHECK_NULL_PTR(st, "rcs_demo", "store is NULL");
  RA8_CHECK_NULL_PTR(cfg, "rcs_demo", "cfg is NULL");
  ra8_cache_store_reader_t rd = {};
  ra8_err_t                rc = ra8_cache_store_get(st, key, &rd);
  if (rc != k_ra8_ok) {
    return rc;
  }
  if (rd.byte_len != len) {
    return k_ra8_err_invalid_state;
  }
  (void)memset(cfg->scratch, 0, (size_t)len);
  rc = ra8_cache_store_read(&rd, 0U, cfg->scratch, len);
  if (rc != k_ra8_ok) {
    return rc;
  }
  if (!internal_demo_matches(cfg->scratch, len, seed)) {
    return k_ra8_err_invalid_state;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_demo_phase_seed(ra8_cache_store_t*            st,
                                                       const cache_store_demo_cfg_t* cfg)
{
  RA8_CHECK_NULL_PTR(st, "rcs_demo", "store is NULL");
  RA8_CHECK_NULL_PTR(cfg, "rcs_demo", "cfg is NULL");
  ra8_err_t rc =
    internal_demo_put_and_verify(st, k_demo_key_cover, k_demo_seed_cover, k_demo_len_cover, cfg);
  if (rc != k_ra8_ok) {
    return rc;
  }
  rc =
    internal_demo_put_and_verify(st, k_demo_key_tile_a, k_demo_seed_tile_a, k_demo_len_tile_a, cfg);
  if (rc != k_ra8_ok) {
    return rc;
  }
  rc =
    internal_demo_put_and_verify(st, k_demo_key_tile_b, k_demo_seed_tile_b, k_demo_len_tile_b, cfg);
  if (rc != k_ra8_ok) {
    return rc;
  }
  return internal_demo_put_and_verify(st,
                                      k_demo_key_tile_c,
                                      k_demo_seed_tile_c,
                                      k_demo_len_tile_c,
                                      cfg);
}

RA8_INTERNAL static ra8_err_t internal_demo_phase_evict(ra8_cache_store_t* st)
{
  RA8_CHECK_NULL_PTR(st, "rcs_demo", "store is NULL");
  ra8_err_t rc = ra8_cache_store_pin(st, k_demo_key_cover, true);
  if (rc != k_ra8_ok) {
    return rc;
  }
  rc = ra8_cache_store_evict(st, k_demo_key_tile_b);
  if (rc != k_ra8_ok) {
    return rc;
  }
  ra8_cache_store_reader_t rd = {};
  if (ra8_cache_store_get(st, k_demo_key_tile_b, &rd) != k_ra8_err_not_found) {
    return k_ra8_err_invalid_state; /* evicted entry must be a miss */
  }
  if (ra8_cache_store_get(st, k_demo_key_tile_a, &rd) != k_ra8_ok) {
    return k_ra8_err_invalid_state; /* survivor must resolve */
  }
  if (ra8_cache_store_get(st, k_demo_key_tile_c, &rd) != k_ra8_ok) {
    return k_ra8_err_invalid_state; /* survivor must resolve */
  }
  if (ra8_cache_store_evict(st, k_demo_key_cover) != k_ra8_err_busy) {
    return k_ra8_err_invalid_state; /* pinned entry must refuse eviction */
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_demo_verify_survivors(const ra8_cache_store_t*      st,
                                                             const cache_store_demo_cfg_t* cfg)
{
  RA8_CHECK_NULL_PTR(st, "rcs_demo", "store is NULL");
  RA8_CHECK_NULL_PTR(cfg, "rcs_demo", "cfg is NULL");
  ra8_err_t rc =
    internal_demo_get_and_verify(st, k_demo_key_cover, k_demo_seed_cover, k_demo_len_cover, cfg);
  if (rc != k_ra8_ok) {
    return rc;
  }
  rc =
    internal_demo_get_and_verify(st, k_demo_key_tile_a, k_demo_seed_tile_a, k_demo_len_tile_a, cfg);
  if (rc != k_ra8_ok) {
    return rc;
  }
  rc =
    internal_demo_get_and_verify(st, k_demo_key_tile_c, k_demo_seed_tile_c, k_demo_len_tile_c, cfg);
  if (rc != k_ra8_ok) {
    return rc;
  }
  return internal_demo_get_and_verify(st,
                                      k_demo_key_tile_d,
                                      k_demo_seed_tile_d,
                                      k_demo_len_tile_d,
                                      cfg);
}

RA8_INTERNAL static ra8_err_t internal_demo_phase_remount(const cache_store_demo_cfg_t* cfg,
                                                          cache_store_demo_result_t*    out)
{
  RA8_CHECK_NULL_PTR(cfg, "rcs_demo", "cfg is NULL");
  RA8_CHECK_NULL_PTR(out, "rcs_demo", "out is NULL");
  /* Reboot: control state is lost, the media survives. */
  (void)memset(cfg->index, 0, (size_t)cfg->index_cap * sizeof(cfg->index[0]));
  (void)memset(cfg->staging, 0, (size_t)cfg->staging_bytes);
  ra8_cache_store_cfg_t cs2 = {};
  if (internal_demo_build_cfg(cfg, false, &cs2) != k_ra8_ok) {
    out->status = k_cache_store_demo_err_remount;
    return k_ra8_err_invalid_state;
  }
  ra8_cache_store_t st2 = {};
  if (ra8_cache_store_init(&st2, &cs2) != k_ra8_ok) {
    out->status = k_cache_store_demo_err_remount;
    return k_ra8_err_invalid_state;
  }
  out->last_stage = k_cache_store_demo_stage_remounted;
  if (internal_demo_verify_survivors(&st2, cfg) != k_ra8_ok) {
    out->status = k_cache_store_demo_err_persist;
    return k_ra8_err_invalid_state;
  }
  out->survivors              = k_demo_survivors;
  ra8_cache_store_reader_t rd = {};
  if (ra8_cache_store_get(&st2, k_demo_key_tile_b, &rd) != k_ra8_err_not_found) {
    out->status = k_cache_store_demo_err_persist;
    return k_ra8_err_invalid_state;
  }
  out->evicted_stayed_gone = true;
  if (ra8_cache_store_evict(&st2, k_demo_key_cover) != k_ra8_err_busy) {
    out->status = k_cache_store_demo_err_persist;
    return k_ra8_err_invalid_state;
  }
  out->pin_survived = true;
  (void)ra8_cache_store_close(&st2);
  return k_ra8_ok;
}
 
ra8_err_t cache_store_demo_run(const cache_store_demo_cfg_t* cfg, cache_store_demo_result_t* out)
{
  RA8_CHECK_NULL_PTR(cfg, "rcs_demo", "cfg is NULL");
  RA8_CHECK_NULL_PTR(out, "rcs_demo", "out is NULL");
  *out = (cache_store_demo_result_t){
    .status              = k_cache_store_demo_err_arg,
    .last_stage          = k_cache_store_demo_stage_none,
    .survivors           = 0U,
    .evicted_key         = k_demo_key_tile_b,
    .evicted_stayed_gone = false,
    .pin_survived        = false,
  };
 
  ra8_cache_store_cfg_t cs = {};
  if (internal_demo_build_cfg(cfg, true, &cs) != k_ra8_ok) {
    out->status = k_cache_store_demo_err_mount;
    return k_ra8_err_invalid_state;
  }
  ra8_cache_store_t st = {};
  if (ra8_cache_store_init(&st, &cs) != k_ra8_ok) {
    out->status = k_cache_store_demo_err_mount;
    return k_ra8_err_invalid_state;
  }
  out->last_stage = k_cache_store_demo_stage_mounted;
 
  if (internal_demo_phase_seed(&st, cfg) != k_ra8_ok) {
    out->status = k_cache_store_demo_err_seed;
    return k_ra8_err_invalid_state;
  }
  out->last_stage = k_cache_store_demo_stage_seeded;
 
  if (internal_demo_phase_evict(&st) != k_ra8_ok) {
    out->status = k_cache_store_demo_err_evict;
    return k_ra8_err_invalid_state;
  }
  out->last_stage = k_cache_store_demo_stage_evicted;
 
  /* Reuse: the sectors tile_b freed now hold tile_d. */
  if (internal_demo_put_and_verify(&st,
                                   k_demo_key_tile_d,
                                   k_demo_seed_tile_d,
                                   k_demo_len_tile_d,
                                   cfg) != k_ra8_ok) {
    out->status = k_cache_store_demo_err_reuse;
    return k_ra8_err_invalid_state;
  }
  out->last_stage = k_cache_store_demo_stage_reused;
 
  if (ra8_cache_store_close(&st) != k_ra8_ok) {
    out->status = k_cache_store_demo_err_close;
    return k_ra8_err_invalid_state;
  }
  out->last_stage = k_cache_store_demo_stage_closed;
 
  if (internal_demo_phase_remount(cfg, out) != k_ra8_ok) {
    return k_ra8_err_invalid_state; /* internal_demo_phase_remount set out->status */
  }
  out->last_stage = k_cache_store_demo_stage_persisted;
  out->status     = k_cache_store_demo_ok;
  return k_ra8_ok;
}