framealloc 0.11.1

Intent-aware, thread-smart memory allocation for Rust game engines
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

//! Streaming allocator example for large assets.
//!
//! Run with: cargo run --example streaming_assets

use framealloc::{SmartAlloc, AllocConfig, StreamPriority};

fn main() {
    println!("=== Streaming Allocator Example ===\n");

    let alloc = SmartAlloc::new(AllocConfig::default());
    let streaming = alloc.streaming();

    // Simulate loading textures
    println!("1. Reserving space for textures...");
    
    let texture_1 = streaming.reserve(1024 * 1024, StreamPriority::Normal)
        .expect("failed to reserve texture 1");
    println!("   Reserved 1MB for texture 1 (id: {:?})", texture_1.raw());
    
    let texture_2 = streaming.reserve(512 * 1024, StreamPriority::High)
        .expect("failed to reserve texture 2");
    println!("   Reserved 512KB for texture 2 (high priority, id: {:?})", texture_2.raw());

    // Simulate loading data
    println!("\n2. Loading texture data...");
    
    let ptr = streaming.begin_load(texture_1).expect("begin_load failed");
    println!("   Started loading texture 1 at {:?}", ptr);
    
    // Simulate progress
    streaming.report_progress(texture_1, 512 * 1024);
    println!("   Texture 1: 50% loaded");
    
    streaming.report_progress(texture_1, 1024 * 1024);
    streaming.finish_load(texture_1);
    println!("   Texture 1: 100% loaded, ready to use");

    // Load texture 2
    streaming.begin_load(texture_2);
    streaming.finish_load(texture_2);
    println!("   Texture 2: loaded and ready");

    // Access textures
    println!("\n3. Accessing textures...");
    
    if let Some(data) = streaming.access(texture_1) {
        println!("   Texture 1 accessible at {:?}", data);
    }

    // Statistics
    println!("\n4. Streaming Statistics:");
    let stats = streaming.stats();
    println!("   Budget: {} bytes", stats.budget);
    println!("   Reserved: {} bytes", stats.total_reserved);
    println!("   Loaded: {} bytes", stats.total_loaded);
    println!("   Active allocations: {}", stats.allocation_count);
    println!("   Ready: {}", stats.ready_count);

    // Free textures
    println!("\n5. Freeing textures...");
    streaming.free(texture_1);
    streaming.free(texture_2);
    println!("   All textures freed");

    let stats = streaming.stats();
    println!("   Final reserved: {} bytes", stats.total_reserved);

    println!("\n=== Done ===");
}