Crate platform_mem 

Low-level memory management with pluggable backends.

platform-mem provides a unified RawMem trait that abstracts over different memory storage strategies: heap allocators, memory-mapped files, and temporary files. Code written against RawMem works with any backend.

Backends

Type	Storage	Use case
Global<T>	Rust global allocator	General-purpose in-memory storage
System<T>	System allocator	When you need the OS allocator specifically
Alloc<T, A>	Any Allocator	Custom allocator strategies
FileMapped<T>	Memory-mapped file	Persistent storage, large datasets
TempFile<T>	Temporary mmap file	Anonymous storage cleaned on drop
AsyncFileMem<T>	Async mmap via I/O thread	Non-blocking file-backed storage (requires async feature)

Quick start

use platform_mem::{Global, RawMem};

let mut mem = Global::<u64>::new();
mem.grow_filled(3, 42).unwrap();
assert_eq!(mem.allocated(), &[42, 42, 42]);

mem.grow_from_slice(&[1, 2, 3]).unwrap();
assert_eq!(mem.allocated(), &[42, 42, 42, 1, 2, 3]);

mem.shrink(2).unwrap();
assert_eq!(mem.allocated(), &[42, 42, 42, 1]);

Type erasure

Use ErasedMem to work with heterogeneous memory backends via dynamic dispatch:

use platform_mem::{Global, ErasedMem, RawMem};

fn use_any_mem(mem: &mut Box<dyn ErasedMem<Item = u64>>) {
    mem.grow_filled(5, 0).unwrap();
}

let mut mem: Box<dyn ErasedMem<Item = u64>> = Box::new(Global::<u64>::new());
use_any_mem(&mut mem);
assert_eq!(mem.allocated().len(), 5);

Features

• async — enables [AsyncFileMem] for non-blocking file-backed memory via a dedicated I/O thread (requires tokio).

Re-exports

pub use raw_mem::ErasedMem;

pub use raw_mem::Error;

pub use raw_mem::RawMem;

pub use raw_mem::Result;

Modules

raw_mem

Core trait definitions, error types, and MaybeUninit helpers.

Structs

Alloc

Allocator-backed memory storage.

FileMapped

Memory-mapped file storage.

Global

Memory backed by the Rust global allocator.

System

Memory backed by the system allocator.

TempFile

Temporary file-backed memory-mapped storage.