ra8_slab.c

Go to the documentation of this file.

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

static const char* const s_tag = "ra8_slab";

RA8_INTERNAL
RA8_INTERNAL static uint32_t internal_slab_next(const ra8_slab_t* slab, uint32_t idx)
{
  uint32_t next = 0U;
  (void)memcpy(&next, &slab->base[(size_t)idx * (size_t)slab->cell_bytes], sizeof(next));
  return next;
}

RA8_INTERNAL
RA8_INTERNAL static void internal_slab_set_next(ra8_slab_t* slab, uint32_t idx, uint32_t next)
{
  (void)memcpy(&slab->base[(size_t)idx * (size_t)slab->cell_bytes], &next, sizeof(next));
}
 
ra8_err_t ra8_slab_init(ra8_slab_t* slab, void* buffer, uint32_t buffer_bytes, uint32_t cell_bytes)
{
  RA8_CHECK_NULL_PTR(slab, s_tag, "slab must not be nullptr");
  RA8_CHECK_NULL_PTR(buffer, s_tag, "buffer must not be nullptr");
  if (cell_bytes < (uint32_t)k_ra8_slab_min_cell_bytes) {
    return k_ra8_err_invalid_size;
  }
  if ((cell_bytes % (uint32_t)k_ra8_slab_align_bytes) != 0U) {
    return k_ra8_err_invalid_size;
  }
  const uint32_t count = buffer_bytes / cell_bytes;
  if (count == 0U) {
    return k_ra8_err_invalid_size;
  }
  slab->base       = (uint8_t*)buffer;
  slab->cell_bytes = cell_bytes;
  slab->cell_count = count;
  for (uint32_t i = 0U; i < count; ++i) {
    const uint32_t next = ((i + 1U) < count) ? (i + 1U) : (uint32_t)k_ra8_slab_nil;
    internal_slab_set_next(slab, i, next);
  }
  slab->free_head  = 0U;
  slab->free_count = count;
  return k_ra8_ok;
}
 
ra8_err_t ra8_slab_alloc(ra8_slab_t* slab, void** out_cell)
{
  RA8_CHECK_NULL_PTR(slab, s_tag, "slab must not be nullptr");
  RA8_CHECK_NULL_PTR(out_cell, s_tag, "out_cell must not be nullptr");
  if (slab->free_head == (uint32_t)k_ra8_slab_nil) {
    return k_ra8_err_no_mem;
  }
  const uint32_t idx = slab->free_head;
  slab->free_head    = internal_slab_next(slab, idx);
  slab->free_count--;
  *out_cell = (void*)&slab->base[(size_t)idx * (size_t)slab->cell_bytes];
  return k_ra8_ok;
}
 
ra8_err_t ra8_slab_free(ra8_slab_t* slab, void* cell)
{
  RA8_CHECK_NULL_PTR(slab, s_tag, "slab must not be nullptr");
  RA8_CHECK_NULL_PTR(cell, s_tag, "cell must not be nullptr");
  const uintptr_t cell_addr = (uintptr_t)cell;
  const uintptr_t base_addr = (uintptr_t)slab->base;
  if (cell_addr < base_addr) {
    return k_ra8_err_invalid_arg;
  }
  const uintptr_t off  = cell_addr - base_addr;
  const uintptr_t span = (uintptr_t)slab->cell_count * (uintptr_t)slab->cell_bytes;
  if (off >= span) {
    return k_ra8_err_invalid_arg;
  }
  if ((off % (uintptr_t)slab->cell_bytes) != 0U) {
    return k_ra8_err_invalid_arg;
  }
  const uint32_t idx = (uint32_t)(off / (uintptr_t)slab->cell_bytes);
  internal_slab_set_next(slab, idx, slab->free_head);
  slab->free_head = idx;
  slab->free_count++;
  return k_ra8_ok;
}
 
ra8_err_t ra8_slab_stats(const ra8_slab_t* slab, uint32_t* out_free, uint32_t* out_total)
{
  RA8_CHECK_NULL_PTR(slab, s_tag, "slab must not be nullptr");
  if (slab->base == nullptr) {
    return k_ra8_err_invalid_state;
  }
  if (out_free != nullptr) {
    *out_free = slab->free_count;
  }
  if (out_total != nullptr) {
    *out_total = slab->cell_count;
  }
  return k_ra8_ok;
}