TikuOS: Simple. Ubiquitous. Intelligence, Everywhere.

Memory Management

TikuOS has no heap. Instead, it provides a small toolbox of static allocators — arenas, pools, write-back caches, and a persistent key-value store — each backed by caller-provided buffers in either SRAM or FRAM. A tier abstraction lets a caller request memory from a specific tier, and an MPU layer protects FRAM from accidental writes. The result: predictable memory behavior, no fragmentation, and safe handling of non-volatile state.

Header: kernel/memory/tiku_mem.h.

Initialization

Error Codes

typedef enum {
    TIKU_MEM_OK            =  0,    /* Success                              */
    TIKU_MEM_ERR_INVALID   = -1,    /* Invalid argument                     */
    TIKU_MEM_ERR_NOMEM     = -2,    /* Out of memory                        */
    TIKU_MEM_ERR_FULL      = -3,    /* Store is full                        */
    TIKU_MEM_ERR_NOT_FOUND = -4     /* Key not found                        */
} tiku_mem_err_t;

Memory Tiers

typedef enum {
    TIKU_MEM_SRAM = 0,  /* Fast, volatile                                   */
    TIKU_MEM_NVM  = 1,  /* Persistent, slower writes (FRAM)                 */
    TIKU_MEM_AUTO = 2   /* OS selects: prefers SRAM, falls back to NVM      */
} tiku_mem_tier_t;

Arena Allocator

Bump-pointer allocator: hand out aligned memory from a fixed buffer, reset all allocations at once. There is no individual free operation.

typedef struct {
    uint8_t              *buf;
    tiku_mem_arch_size_t  capacity;
    tiku_mem_arch_size_t  offset;
    tiku_mem_arch_size_t  peak;
    tiku_mem_arch_size_t  count;
    uint8_t               id;
    uint8_t               active;
    tiku_mem_tier_t       tier;
} tiku_arena_t;

Pool Allocator

Fixed-size block allocator with an embedded freelist. O(1) allocation and free; zero per-block metadata overhead.

typedef struct {
    uint8_t              *buf;
    tiku_mem_arch_size_t  block_size;
    tiku_mem_arch_size_t  block_count;
    void                 *free_head;
    tiku_mem_arch_size_t  used_count;
    tiku_mem_arch_size_t  peak_count;
    uint8_t               id;
    uint8_t               active;
    tiku_mem_tier_t       tier;
} tiku_pool_t;

Region Registry

Platform memory map management and overlap detection. Allows allocators to verify that a given buffer lives in a permitted region (e.g. SRAM, FRAM) and claim exclusive ownership.

Persistent NVM Key-Value Store

Stores small, named values in FRAM that survive power cycles. Each key is associated with a fixed-size FRAM buffer; reads copy into SRAM and writes go directly to FRAM under MPU control.

MPU (Memory Protection Unit)

Protects FRAM from accidental writes. In normal operation the NVM segment is mapped read-only; code that needs to write FRAM must explicitly unlock the MPU, perform the write, and lock it again. Violations can be configured to trigger either a reset or an NMI.

typedef enum { TIKU_MPU_SEG1, TIKU_MPU_SEG2, TIKU_MPU_SEG3 } tiku_mpu_seg_t;

typedef enum {
    TIKU_MPU_READ    = 0x01,
    TIKU_MPU_WRITE   = 0x02,
    TIKU_MPU_EXEC    = 0x04,
    TIKU_MPU_RD_WR   = 0x03,
    TIKU_MPU_RD_EXEC = 0x05,
    TIKU_MPU_ALL     = 0x07
} tiku_mpu_perm_t;

Tier Allocator

Creates arenas and pools backed by a specific memory tier (SRAM or NVM). Useful when a subsystem wants to request "some NVM memory" without caring which buffer it ends up in.

Write-Back Cache

Pairs an SRAM working copy with a FRAM backing store. Reads and writes hit the fast SRAM copy; dirty regions are flushed to FRAM on demand or before entering low-power mode. This is how frequently-touched persistent state (e.g. boot tables) avoids wearing out the FRAM.

typedef struct {
    uint8_t              *sram_cache;
    uint8_t              *fram_backing;
    tiku_mem_arch_size_t  size;
    uint8_t               dirty;
    uint8_t               active;
} tiku_cached_region_t;

Process Memory Context

Binds an SRAM scratch arena, an NVM persistent arena, and any attached cached regions to a single process. Lets a process allocate memory that is freed when it exits.

Hibernate / Resume

Flushes caches to FRAM, writes a hibernate marker, and later checks that marker on boot to decide whether the system is resuming from a warm state.