memkit-async

Task-Local, Async-Native Memory Management for Rust.

⚡ The Async Challenge

In traditional Rust async, using stack-based or frame-based allocators is dangerous. Resuming a task on a different thread or after a lifetime has expired leads to undefined behavior.

memkit-async solves this by introducing Task-Local Allocation Contexts. Your memory remains valid and local to the logical task, even as it migrates across the thread pool of an executor like tokio.

💎 The Async Advantage

✨ Features

• 🧶 Task-Local Arenas — Each async task gets its own isolated, high-speed allocation context.
• 🛑 Backpressure Semantics — Configurable behavior (Wait, Fail, Timeout) when memory limits are reached.
• 📦 Lock-Free Object Pools — High-performance object reuse with async acquisition.
• 🚀 Zero-Copy Channels — Move ownership of entire arenas between tasks without a single mem-copy.
• 🛡️ Await-Safe — Integrated with the task lifecycle to ensure memory remains valid across .await.

🛠️ Quick Start

use memkit_async::{MkAsyncFrameAlloc, MkAsyncFrameConfig};

#[tokio::main]
async fn main() {
    let alloc = MkAsyncFrameAlloc::new(MkAsyncFrameConfig::default());
    
    // Begin a task-scoped frame
    let frame = alloc.begin_frame().await;
    
    // Allocate high-speed data that is safe across await points
    let data = alloc.alloc::<BigData>().await;
    
    do_some_io().await; // Task might move threads here...
    
    process(data);      // ...but our memory remains safe and contiguous!
    
    drop(frame);
}

🏗️ Backpressure Policies

When your async tasks are memory-hungry, memkit-async keeps the system stable:

🔌 Integration

Enable the tokio feature for first-class support for the Tokio runtime:

[dependencies]

memkit-async = { version = "0.1.1-beta.1", features = ["tokio"] }

⚖️ License

Licensed under the Mozilla Public License 2.0. See LICENSE.md for details.