memkit 0.1.0-alpha.1

Deterministic, intent-driven memory allocation for systems requiring predictable performance
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

# memkit


**Core CPU memory allocation primitives for the memkit ecosystem.**

> **Version:** 0.1.0-alpha.1

[![Crates.io](https://img.shields.io/crates/v/memkit.svg)](https://crates.io/crates/memkit)
[![Documentation](https://docs.rs/memkit/badge.svg)](https://docs.rs/memkit)
[![License: MPL-2.0](https://img.shields.io/badge/License-MPL%202.0-brightgreen.svg)](https://opensource.org/licenses/MPL-2.0)

## Overview


memkit provides deterministic, intent-driven memory allocation for game engines and real-time applications. It offers predictable performance through explicit lifetimes and zero-cost abstractions.

## Features


- **Frame Arenas** — O(1) bump allocation, instant bulk reset per frame
- **Object Pools** — O(1) allocation/deallocation for small objects
- **Heap Allocation** — Tracked heap allocations with statistics
- **Scoped Allocation** — RAII-style checkpoint/restore within frames
- **Thread-Local Fast Paths** — Per-thread arenas avoid contention

## Quick Start


```rust
use memkit::{MkAllocator, MkConfig};

let alloc = MkAllocator::new(MkConfig::default());

// Game loop
loop {
    alloc.begin_frame();
    
    // Frame allocations - ultra fast, reset automatically
    let positions = alloc.frame_slice::<[f32; 3]>(1000).unwrap();
    let velocities = alloc.frame_slice::<[f32; 3]>(1000).unwrap();
    
    // Pool allocations - returned to pool on drop
    let entity = alloc.pool_box(Entity::new()).unwrap();
    
    // Scoped allocations
    {
        let _scope = alloc.scope();
        let temp = alloc.frame_box(TempData::new()).unwrap();
        // temp freed when scope drops
    }
    
    alloc.end_frame(); // Instant reset
}
```

## Types


| Type | Description |
|------|-------------|
| `MkAllocator` | Main allocator entry point |
| `MkConfig` | Allocator configuration |
| `MkFrameBox<T>` | Frame-allocated box |
| `MkFrameSlice<T>` | Frame-allocated slice |
| `MkFrameVec<T>` | Frame-allocated vector |
| `MkPoolBox<T>` | Pool-allocated box |
| `MkHeapBox<T>` | Heap-allocated box |
| `MkScope` | Scoped checkpoint guard |

## Configuration


```rust
let config = MkConfig {
    frame_arena_size: 64 * 1024 * 1024, // 64 MB per thread
    slab_size_classes: vec![16, 32, 64, 128, 256, 512, 1024, 2048, 4096],
    debug_mode: cfg!(debug_assertions),
    ..Default::default()
};
```

## License


This project is licensed under the Mozilla Public License 2.0 - see the [LICENSE.md](../LICENSE.md) file for details.