ra8_img_arena.c

Go to the documentation of this file.

 
#include "ra8_img_arena.h"
 
#include <stddef.h>
#include <stdint.h>
#include <string.h>

typedef enum : uint32_t {
  k_ra8_img_align      = 16U, 
  k_ra8_img_align_mask = 15U, 
} ra8_img_arena_consts_t;

static ra8_img_arena_t* s_arena = nullptr;
 
void ra8_img_arena_bind(ra8_img_arena_t* arena)
{
  s_arena = arena;
  if (arena != nullptr) {
    arena->offset = 0U;
    arena->live   = 0U;
  }
}
 
void ra8_img_arena_unbind(void)
{
  s_arena = nullptr;
}
 
void* ra8_img_arena_malloc(size_t n)
{
  ra8_img_arena_t* const a = s_arena;
  if (a == nullptr) {
    return nullptr;
  }
  /* Reject requests too large to ever fit; this also prevents the alignment
   * round-up below from overflowing. */
  if (n > a->cap) {
    return nullptr;
  }
  const size_t aligned = (n + (size_t)k_ra8_img_align_mask) & ~(size_t)k_ra8_img_align_mask;
  if (aligned > (a->cap - a->offset)) {
    return nullptr;
  }
  void* const block = &a->base[a->offset];
  a->offset += aligned;
  a->live += 1U;
  return block;
}
 
void ra8_img_arena_free(void* p)
{
  ra8_img_arena_t* const a = s_arena;
  if ((p == nullptr) || (a == nullptr)) {
    return;
  }
  if (a->live > 0U) {
    a->live -= 1U;
  }
  if (a->live == 0U) {
    a->offset = 0U;
  }
}
 
void* ra8_img_arena_realloc_sized(void* p, size_t oldsz, size_t newsz)
{
  if (p == nullptr) {
    return ra8_img_arena_malloc(newsz);
  }
  /* A bump arena cannot grow in place: allocate fresh, copy, release old. */
  void* const fresh = ra8_img_arena_malloc(newsz);
  if (fresh == nullptr) {
    return nullptr;
  }
  const size_t copy = (oldsz < newsz) ? oldsz : newsz;
  if (copy > 0U) {
    (void)memcpy(fresh, p, copy);
  }
  ra8_img_arena_free(p);
  return fresh;
}