Struct GpuAgentState 

pub struct GpuAgentState<M: GpuAgentModel> { /* private fields */ }

GPU-resident state for a GpuAgentModel, with every buffer, pass and bind group its model declares.

Implementations

impl<M: GpuAgentModel> GpuAgentState<M>

pub fn new(ctx: &GpuContext, params: &[ParamValue]) -> Self

Builds the state on ctx, seeded with the model’s default seed.

Panics

Panics as Self::new_seeded does.

pub fn geometry_for(params: &[ParamValue], limits: &Limits) -> Geometry

Returns the geometry for params, without touching a device. limits sets only the display cap.

pub fn demand(params: &[ParamValue], limits: &Limits) -> Demand

Resources that would be allocated for this model based on params.

pub fn max_storage_bindings() -> u32

Returns the most storage buffers any declared pass binds. It does not depend on params, so a host can query it before it has a device.

pub fn new_seeded( ctx: &GpuContext, params: &[ParamValue], seed: Option<u64>, ) -> Self

Builds the state on ctx, seeded with seed, or with the model’s own default seed when it is None.

Panics

Panics if the device cannot hold the model. A host calls Self::demand first, and this assert is the backstop. Also panics if a shader declares a workgroup size other than the one its pass dispatches, or a buffer label is reserved or ends in _in or _out.

pub fn run_batched(&mut self, steps: u32)

Submits steps steps, at most MAX_STEPS_PER_SUBMISSION per command buffer, as the runner does. Nothing waits on the GPU.

pub fn refresh_stats(&mut self)

Runs the snapshot passes and waits for the readback, so stats() reports the current tick.

pub fn read_buffer(&self, index: usize) -> Vec<u32>

Returns the current side of buffer index as raw words, blocking on the GPU.

Panics

Panics if the readback fails.

pub fn geometry(&self) -> &Geometry

Geometry the state was built at.

Trait Implementations

impl<M: GpuAgentModel> Debug for GpuAgentState<M>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<M: GpuAgentModel> GpuSimState for GpuAgentState<M>

fn encode_steps( &mut self, encoder: &mut CommandEncoder, count: u32, timestamps: Option<&QuerySet>, )

Records one compute pass per declared pass per step, all into one encoder.

A pass is the synchronization boundary wgpu inserts barriers at, so a step’s passes cannot be collapsed into dispatches inside one pass. The later ones would read stale data.

fn encode_action(&mut self, encoder: &mut CommandEncoder, index: usize) -> bool

Records the model’s declared action at index, and returns whether the model declares one.

fn encode_snapshot_passes(&mut self, encoder: &mut CommandEncoder)

Records the display pass (state -> display texture) and the stats-reduction pass (state -> a handful of numbers), at the snapshot cadence rather than every step.

fn encode_stats_passes(&mut self, encoder: &mut CommandEncoder)

Records the stats-reduction passes of Self::encode_snapshot_passes, without its display pass.

fn begin_stats_readback(&mut self)

Starts the async stats readback.

fn poll_stats_readback(&mut self, device: &Device, block: bool) -> StatsPoll

Completes an in-flight stats readback, updating what SimState::stats() returns.

fn stats_readback_pending(&self) -> bool

Returns whether a readback started by Self::begin_stats_readback has not completed yet.

fn view(&self) -> GpuSnapshot

Returns the layers the UI draws.

impl<M: GpuAgentModel> SimState for GpuAgentState<M>

fn step(&mut self)

Steps once in its own submission, for a caller that holds only a SimState. The GPU runner batches instead.

fn act(&mut self, index: usize) -> bool

Encodes the action into its own submission.

The GPU runner calls GpuSimState::encode_action instead, and submits the action before its snapshot.

fn set_param(&mut self, _index: usize, _value: &ParamValue) -> bool

Rejects every live edit. Its entry declares every parameter reload-only.

fn tick(&self) -> u64

Number of ticks stepped so far.

fn stats(&self) -> Vec<StatEntry>

Returns the current statistics, one entry per declared series.

fn population(&self) -> u64

Size of the population: its cells, its agents or its live nodes.

fn heap_bytes(&self) -> usize

Approximate size in bytes of the memory this state owns, on the host for a CPU state and on the device for a GPU state.

fn grid_view(&self) -> Option<GridView<'_>>

Returns the grid layer to draw, if the state has one.

fn point_view(&self) -> Option<PointView<'_>>

Returns the agents to draw, if the state has any.

fn edge_view(&self) -> Option<EdgeView<'_>>

Returns the edges to draw between the positions from SimState::point_view.

fn prepare_view(&mut self)

Prepares the views before a snapshot is built.

fn set_layout(&mut self, _on: bool, _budget_ms: f32) -> bool

Turns the layout on or off, with a time budget per publish in milliseconds.

fn relax_layout(&mut self)

Runs the layout for one time budget, if it is on.

fn parallel_jobs(&self) -> Option<usize>

Number of jobs that one step splits into. None if a backend has no such split.