Struct GpuGridState 

pub struct GpuGridState<M: GpuGridModel> { /* private fields */ }

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

Implementations

impl<M: GpuGridModel> GpuGridState<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 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 fixed 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 GpuGridModel::WORKGROUP_SIZE, or a buffer label is reserved or ends in _in or _out.

Trait Implementations

impl<M: GpuGridModel> Debug for GpuGridState<M>

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

Formats the value using the given formatter.

impl<M: GpuGridModel> GpuSimState for GpuGridState<M>

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

Records count step dispatches into encoder, one compute pass per step.

Each step is a read-after-write hazard on the ping-ponged state buffers, and wgpu inserts barriers only between passes. Dispatches looped inside one pass would read stale data. Batching happens at the submission level instead, with one encoder for all count passes.

If timestamps is Some, the first pass’s beginning and the last pass’s end are stamped into query indices 0 and 1 so the caller can measure GPU time for the whole batch.

fn view(&self) -> GpuSnapshot

Returns the display layer alone. A GpuGridModel has no agent layer.

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.

impl<M: GpuGridModel> SimState for GpuGridState<M>

fn step(&mut self)

Steps once in its own submission, for a caller that holds only a SimState. The GPU runner calls encode_steps directly and batches the steps.

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.