Struct TickBarrier 

pub struct TickBarrier { /* private fields */ }

Barrier ensuring all shards complete a phase before any proceeds.

The tick barrier coordinates the phases within each simulation tick:

1. Sense - agents sense the substrate (read-only phase)
2. Act - process agent actions (write phase)
3. Decay - decay signals, traces, and edges (maintenance phase)
4. Advance - advance tick counter (finalization phase)

Each shard must signal completion of each phase, and all shards must complete before any can proceed to the next phase.

Implementations

impl TickBarrier

pub fn new(shard_count: usize) -> Self

Create a new tick barrier for the specified number of shards.

pub fn with_timeout(shard_count: usize, timeout_secs: u64) -> Self

Create a tick barrier with custom timeout.

pub async fn set_shard_count(&self, count: usize)

Update the expected shard count.

This should be called when shards are added or removed from the cluster.

pub async fn shard_count(&self) -> usize

Get the current shard count.

pub async fn complete( &self, shard_id: ShardId, phase: TickPhase, tick: Tick, ) -> DistributedResult<()>

Mark a shard as having completed a phase.

Arguments

• shard_id - The shard that completed
• phase - The phase that was completed
• tick - The tick number

pub async fn is_complete( &self, shard_id: ShardId, phase: TickPhase, tick: Tick, ) -> bool

Check if a specific shard has completed a phase.

pub async fn completed_count(&self, phase: TickPhase, tick: Tick) -> usize

Get the number of shards that have completed a phase.

pub async fn wait_all( &self, phase: TickPhase, tick: Tick, ) -> DistributedResult<()>

Wait for all shards to complete a phase.

This will block until all registered shards have signaled completion of the specified phase, or until the timeout is reached.

Arguments

• phase - The phase to wait for
• tick - The tick number

Errors

Returns DistributedError::PhaseTimeout if the timeout is reached before all shards complete.

pub async fn wait_all_with_timeout( &self, phase: TickPhase, tick: Tick, timeout: Duration, ) -> DistributedResult<()>

Wait for all shards with custom timeout.

pub async fn reset_for_tick(&self, _tick: Tick)

Reset the barrier for a new tick.

This clears all completion records. Should be called before starting a new tick.

pub async fn get_completed_shards( &self, phase: TickPhase, tick: Tick, ) -> Vec<ShardId>

Get all shards that have completed a specific phase.

pub async fn get_pending_shards( &self, phase: TickPhase, tick: Tick, all_shards: &[ShardId], ) -> Vec<ShardId>

Get all shards that have NOT completed a specific phase.