Struct ResourceArena 

pub struct ResourceArena<T> { /* private fields */ }

Bounded resource ownership. GPU users must remove only after last submission completes. This arena does not infer GPU completion or provide a submission timeline.

Implementations

impl<T> ResourceArena<T>

pub fn new(limits: RenderLimits) -> Result<Self, RenderError>

Create a validated empty arena without preallocating payload storage.

Examples found in repository

examples/intermediate.rs (line 13)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut arena = ResourceArena::new(RenderLimits::default())?;
    let id = arena.insert("cpu-owned example resource", 64)?;
    println!("managed_bytes={}", arena.managed_bytes());
    let _resource = arena.remove(id)?;
    assert!(arena.get(id).is_err());
    Ok(())
}

examples/scene_admission.rs (line 44)

fn main() -> Result<()> {
    let mut assets = ResourceArena::new(RenderLimits::default())?;
    let binding = RenderBinding {
        mesh: assets.insert((), 1)?,
        material: assets.insert((), 1)?,
        tint: [1.; 4],
        animation: 0,
        morph: 0,
    };
    eprintln!("CPU admission only; target={}/{}; 1 warmup + 5 samples per size; release build required; allocation/drop excluded; reuse=despawn all + spawn all", std::env::consts::OS, std::env::consts::ARCH);
    println!("entities,initial_median_ns,initial_min_ns,initial_max_ns,reuse_median_ns,reuse_min_ns,reuse_max_ns,reservation_bytes");
    for count in [1024, 8192, 32768] {
        black_box(sample(count, binding)?);
        let mut initial = [0; 5];
        let mut reuse = [0; 5];
        let mut bytes = 0;
        for i in 0..5 {
            let result = sample(count, binding)?;
            (initial[i], reuse[i], bytes) = result;
        }
        initial.sort_unstable();
        reuse.sort_unstable();
        println!(
            "{count},{},{},{},{},{},{},{bytes}",
            initial[2], initial[0], initial[4], reuse[2], reuse[0], reuse[4]
        );
    }
    Ok(())
}

examples/scene.rs (line 17)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Opaque asset identities only; this example qualifies CPU scene ownership, not drawing.
    let mut assets = ResourceArena::new(RenderLimits::default())?;
    let binding = RenderBinding {
        mesh: assets.insert((), 1)?,
        material: assets.insert((), 1)?,
        tint: [1.0; 4],
        animation: 0,
        morph: 0,
    };
    let mut world = SceneWorld::new(SceneLimits {
        max_entities: 64,
        max_snapshot_instances: 64,
        ..Default::default()
    })?;
    let mut first = None;
    for i in 0..64 {
        let id = world.spawn(
            Transform::default().with_position([i as f32, 0.0, 0.0])?,
            binding,
            Some(Velocity::new([1.0, 0.0, 0.0])?),
        )?;
        first = first.or(Some(id));
    }
    let before = world.snapshot()?;
    world.step_velocity(0.016)?;
    let after = world.snapshot()?;
    assert_eq!(before.instances()[0].transform.position()[0], 0.0);
    assert_eq!(after.instances()[0].transform.position()[0], 0.016);
    let mut commands = SceneCommands::new(8)?;
    if let Some(first) = first {
        commands.push(SceneCommand::SetVelocity(first, None))?;
    }
    for outcome in commands.apply(&mut world)? {
        outcome?;
    }
    println!(
        "entities={} owned_snapshots=2 moving_rows={}",
        world.len(),
        world.moving_columns().entities.len()
    );
    Ok(())
}

pub fn insert( &mut self, value: T, bytes: u64, ) -> Result<ResourceId, RenderError>

Admit a resource with its accounted bytes; rejects before arena mutation.

Examples found in repository

examples/intermediate.rs (line 14)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut arena = ResourceArena::new(RenderLimits::default())?;
    let id = arena.insert("cpu-owned example resource", 64)?;
    println!("managed_bytes={}", arena.managed_bytes());
    let _resource = arena.remove(id)?;
    assert!(arena.get(id).is_err());
    Ok(())
}

examples/scene_admission.rs (line 46)

fn main() -> Result<()> {
    let mut assets = ResourceArena::new(RenderLimits::default())?;
    let binding = RenderBinding {
        mesh: assets.insert((), 1)?,
        material: assets.insert((), 1)?,
        tint: [1.; 4],
        animation: 0,
        morph: 0,
    };
    eprintln!("CPU admission only; target={}/{}; 1 warmup + 5 samples per size; release build required; allocation/drop excluded; reuse=despawn all + spawn all", std::env::consts::OS, std::env::consts::ARCH);
    println!("entities,initial_median_ns,initial_min_ns,initial_max_ns,reuse_median_ns,reuse_min_ns,reuse_max_ns,reservation_bytes");
    for count in [1024, 8192, 32768] {
        black_box(sample(count, binding)?);
        let mut initial = [0; 5];
        let mut reuse = [0; 5];
        let mut bytes = 0;
        for i in 0..5 {
            let result = sample(count, binding)?;
            (initial[i], reuse[i], bytes) = result;
        }
        initial.sort_unstable();
        reuse.sort_unstable();
        println!(
            "{count},{},{},{},{},{},{},{bytes}",
            initial[2], initial[0], initial[4], reuse[2], reuse[0], reuse[4]
        );
    }
    Ok(())
}

examples/scene.rs (line 19)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Opaque asset identities only; this example qualifies CPU scene ownership, not drawing.
    let mut assets = ResourceArena::new(RenderLimits::default())?;
    let binding = RenderBinding {
        mesh: assets.insert((), 1)?,
        material: assets.insert((), 1)?,
        tint: [1.0; 4],
        animation: 0,
        morph: 0,
    };
    let mut world = SceneWorld::new(SceneLimits {
        max_entities: 64,
        max_snapshot_instances: 64,
        ..Default::default()
    })?;
    let mut first = None;
    for i in 0..64 {
        let id = world.spawn(
            Transform::default().with_position([i as f32, 0.0, 0.0])?,
            binding,
            Some(Velocity::new([1.0, 0.0, 0.0])?),
        )?;
        first = first.or(Some(id));
    }
    let before = world.snapshot()?;
    world.step_velocity(0.016)?;
    let after = world.snapshot()?;
    assert_eq!(before.instances()[0].transform.position()[0], 0.0);
    assert_eq!(after.instances()[0].transform.position()[0], 0.016);
    let mut commands = SceneCommands::new(8)?;
    if let Some(first) = first {
        commands.push(SceneCommand::SetVelocity(first, None))?;
    }
    for outcome in commands.apply(&mut world)? {
        outcome?;
    }
    println!(
        "entities={} owned_snapshots=2 moving_rows={}",
        world.len(),
        world.moving_columns().entities.len()
    );
    Ok(())
}

pub fn get(&self, id: ResourceId) -> Result<&T, RenderError>

Resolve only a live handle from this arena.

Examples found in repository

examples/intermediate.rs (line 17)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut arena = ResourceArena::new(RenderLimits::default())?;
    let id = arena.insert("cpu-owned example resource", 64)?;
    println!("managed_bytes={}", arena.managed_bytes());
    let _resource = arena.remove(id)?;
    assert!(arena.get(id).is_err());
    Ok(())
}

pub fn remove(&mut self, id: ResourceId) -> Result<T, RenderError>

Remove a resource. Caller must first prove GPU completion for GPU-owned values.

Examples found in repository

examples/intermediate.rs (line 16)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut arena = ResourceArena::new(RenderLimits::default())?;
    let id = arena.insert("cpu-owned example resource", 64)?;
    println!("managed_bytes={}", arena.managed_bytes());
    let _resource = arena.remove(id)?;
    assert!(arena.get(id).is_err());
    Ok(())
}

pub fn managed_bytes(&self) -> u64

Current accounted live bytes; not total driver allocation.

Examples found in repository

examples/intermediate.rs (line 15)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut arena = ResourceArena::new(RenderLimits::default())?;
    let id = arena.insert("cpu-owned example resource", 64)?;
    println!("managed_bytes={}", arena.managed_bytes());
    let _resource = arena.remove(id)?;
    assert!(arena.get(id).is_err());
    Ok(())
}