Struct EnvPool 

pub struct EnvPool {
    pub envs: Vec<GameEnv>,
    pub action_space: usize,
    pub error_policy: ErrorPolicy,
    /* private fields */
}

Pool of independent environments stepped in parallel.

Examples

use std::sync::Arc;
use weiss_core::{
    BatchOutMinimalBuffers, CardDb, CurriculumConfig, DebugConfig, EnvConfig, EnvPool,
};

let mut pool = EnvPool::new_rl_train(
    8,
    Arc::new(db),
    config,
    CurriculumConfig::default(),
    0,
    None,
    DebugConfig::default(),
)?;
let mut buffers = BatchOutMinimalBuffers::new(pool.envs.len());
let mut out = buffers.view_mut();
pool.reset_into(&mut out)?;

let actions = vec![weiss_core::encode::PASS_ACTION_ID as u32; pool.envs.len()];
pool.step_into(&actions, &mut out)?;

Fields

envs: Vec<GameEnv>

Backing environments (one per slot).

action_space: usize

Fixed action space size used by all envs.

error_policy: ErrorPolicy

Error policy applied during stepping.

Implementations

impl EnvPool

pub fn new_rl_train( num_envs: usize, db: Arc<CardDb>, config: EnvConfig, curriculum: CurriculumConfig, seed: u64, num_threads: Option<usize>, debug: DebugConfig, ) -> Result<Self>

Create a pool configured for RL training (public visibility + lenient errors).

pub fn new_rl_eval( num_envs: usize, db: Arc<CardDb>, config: EnvConfig, curriculum: CurriculumConfig, seed: u64, num_threads: Option<usize>, debug: DebugConfig, ) -> Result<Self>

Create a pool configured for RL evaluation (public visibility).

pub fn new_debug( num_envs: usize, db: Arc<CardDb>, config: EnvConfig, curriculum: CurriculumConfig, seed: u64, num_threads: Option<usize>, debug: DebugConfig, ) -> Result<Self>

Create a pool with explicit config and curriculum.

pub fn set_debug_config(&mut self, debug: DebugConfig)

Update debug settings for all envs in the pool.

pub fn engine_error_reset_count(&self) -> u64

Count of auto-resets triggered by engine errors.

pub fn effective_num_threads(&self) -> usize

Effective thread count used by this pool (1 when running serially).

pub fn set_curriculum(&mut self, curriculum: CurriculumConfig)

Replace curriculum settings for all envs in the pool.

pub fn set_error_policy(&mut self, error_policy: ErrorPolicy)

Update error policy for all envs in the pool.

pub fn set_output_mask_enabled(&mut self, enabled: bool)

Enable or disable output action masks for all envs.

pub fn set_output_mask_bits_enabled(&mut self, enabled: bool)

Enable or disable output action mask bits for all envs.

pub fn set_i16_clamp_enabled(&mut self, enabled: bool)

Enable or disable i16 clamping for i16 output buffers.

pub fn set_i16_overflow_counter_enabled(&self, enabled: bool)

Enable or disable counting of i16 overflows.

pub fn i16_overflow_count(&self) -> u64

Total count of i16 clamp overflows since last reset.

pub fn config_hash(&self) -> u64

Stable hash of the pool’s config and curriculum.

pub fn max_card_id(&self) -> u32

Maximum card id available in the underlying database.

pub fn episode_seed_batch(&self) -> Vec<u64>

Episode seeds for each env in the pool.

pub fn episode_index_batch(&self) -> Vec<u32>

Episode indices for each env in the pool.

pub fn env_index_batch(&self) -> Vec<u32>

Environment indices for each env in the pool.

pub fn starting_player_batch(&self) -> Vec<u8>

Starting player for each env in the pool.

pub fn decision_count_batch(&self) -> Vec<u32>

Decision counts for each env in the pool.

pub fn tick_count_batch(&self) -> Vec<u32>

Tick counts for each env in the pool.

pub fn enable_replay_sampling(&mut self, config: ReplayConfig) -> Result<()>

Enable replay sampling for all envs in the pool.

impl EnvPool

pub fn state_fingerprint_batch(&self) -> Vec<u64>

Compute state fingerprints for each env.

pub fn events_fingerprint_batch(&self) -> Vec<u64>

Compute event-stream fingerprints for each env.

pub fn obs_fingerprint_batch(&self) -> Vec<u64>

Compute observation fingerprints for each env.

impl EnvPool

pub fn sample_legal_action_ids_uniform(&self, seeds: &[u64]) -> Result<Vec<u32>>

Sample a legal action id uniformly per env.

pub fn sample_legal_action_ids_uniform_into( &self, seeds: &[u64], out: &mut [u32], ) -> Result<()>

Sample a legal action id uniformly per env into a buffer.

pub fn first_legal_action_ids_into(&self, out: &mut [u32]) -> Result<()>

Write the first legal action id per env into a buffer.

pub fn legal_action_ids_and_sample_uniform_into( &mut self, ids: &mut [u16], offsets: &mut [u32], seeds: &[u64], sampled: &mut [u32], ) -> Result<usize>

Fill legal-id buffers and sample one action per env.

pub fn legal_action_ids_batch_into( &mut self, ids: &mut [u16], offsets: &mut [u32], ) -> Result<usize>

Fill legal-id buffers for all envs.

pub fn legal_actions_batch(&self) -> Vec<Vec<ActionDesc>>

Compute legal action descriptors for all envs.

pub fn get_current_player_batch(&self) -> Vec<i8>

Current decision player per env (-1 if none).

impl EnvPool

pub fn action_masks_batch(&self) -> Result<Vec<u8>>

Fetch dense action masks for all envs.

pub fn action_masks_batch_into(&self, masks: &mut [u8]) -> Result<()>

Fill a provided buffer with dense action masks.

pub fn action_mask_bits_batch(&self) -> Vec<u64>

Fetch packed action mask bits for all envs.

pub fn action_mask_bits_batch_into(&self, bits: &mut [u64]) -> Result<()>

Fill a provided buffer with packed action mask bits.

impl EnvPool

pub fn debug_event_ring_capacity(&self) -> usize

Debug event ring capacity configured for the pool.

pub fn render_ansi(&self, env_index: usize, perspective: u8) -> String

Render a single env to an ANSI string for debugging.

impl EnvPool

pub fn select_actions_from_logits_into( &self, logits: &[f32], out: &mut [u32], ) -> Result<()>

Select the best legal action per env from logits (argmax).

pub fn sample_actions_from_logits_into( &self, logits: &[f32], seeds: &[u64], out: &mut [u32], ) -> Result<()>

Sample a legal action per env from logits using softmax.

pub fn step_select_from_logits_into( &mut self, logits: &[f32], actions: &mut [u32], out: &mut BatchOutMinimal<'_>, ) -> Result<()>

Select from logits and step, filling minimal outputs.

pub fn step_select_from_logits_into_i16( &mut self, logits: &[f32], actions: &mut [u32], out: &mut BatchOutMinimalI16<'_>, ) -> Result<()>

Select from logits and step, filling i16 outputs.

pub fn step_select_from_logits_into_nomask( &mut self, logits: &[f32], actions: &mut [u32], out: &mut BatchOutMinimalNoMask<'_>, ) -> Result<()>

Select from logits and step, filling outputs without masks.

pub fn step_select_from_logits_into_i16_legal_ids( &mut self, logits: &[f32], actions: &mut [u32], out: &mut BatchOutMinimalI16LegalIds<'_>, ) -> Result<()>

Select from logits and step, filling i16 outputs plus legal-id lists.

Requires output masks to be disabled.

pub fn step_sample_from_logits_into( &mut self, logits: &[f32], seeds: &[u64], actions: &mut [u32], out: &mut BatchOutMinimal<'_>, ) -> Result<()>

Sample from logits and step, filling minimal outputs.

pub fn step_sample_from_logits_into_i16( &mut self, logits: &[f32], seeds: &[u64], actions: &mut [u32], out: &mut BatchOutMinimalI16<'_>, ) -> Result<()>

Sample from logits and step, filling i16 outputs.

pub fn step_sample_from_logits_into_nomask( &mut self, logits: &[f32], seeds: &[u64], actions: &mut [u32], out: &mut BatchOutMinimalNoMask<'_>, ) -> Result<()>

Sample from logits and step, filling outputs without masks.

pub fn step_sample_from_logits_into_i16_legal_ids( &mut self, logits: &[f32], seeds: &[u64], actions: &mut [u32], out: &mut BatchOutMinimalI16LegalIds<'_>, ) -> Result<()>

Sample from logits and step, filling i16 outputs plus legal-id lists.

Requires output masks to be disabled.

impl EnvPool

pub fn reset_into(&mut self, out: &mut BatchOutMinimal<'_>) -> Result<()>

Reset all envs and fill a minimal output batch (i32 obs + masks).

pub fn reset_into_i16(&mut self, out: &mut BatchOutMinimalI16<'_>) -> Result<()>

Reset all envs and fill a minimal output batch (i16 obs + masks).

pub fn reset_into_i16_legal_ids( &mut self, out: &mut BatchOutMinimalI16LegalIds<'_>, ) -> Result<()>

Reset all envs and fill i16 outputs plus legal-id lists.

Requires output masks to be disabled.

pub fn reset_into_nomask( &mut self, out: &mut BatchOutMinimalNoMask<'_>, ) -> Result<()>

Reset all envs and fill a minimal output batch without masks.

pub fn reset_indices_into( &mut self, indices: &[usize], out: &mut BatchOutMinimal<'_>, ) -> Result<()>

Reset a subset of envs by index and fill minimal outputs.

Returns Err if any index is out of bounds (>= num_envs).

pub fn reset_indices_into_i16( &mut self, indices: &[usize], out: &mut BatchOutMinimalI16<'_>, ) -> Result<()>

Returns Err if any index is out of bounds (>= num_envs). Reset a subset of envs by index and fill i16 outputs.

pub fn reset_indices_into_i16_legal_ids( &mut self, indices: &[usize], out: &mut BatchOutMinimalI16LegalIds<'_>, ) -> Result<()>

Returns Err if any index is out of bounds (>= num_envs). Reset a subset of envs by index and fill i16 outputs plus legal-id lists.

Requires output masks to be disabled.

pub fn reset_indices_into_nomask( &mut self, indices: &[usize], out: &mut BatchOutMinimalNoMask<'_>, ) -> Result<()>

Returns Err if any index is out of bounds (>= num_envs). Reset a subset of envs by index and fill outputs without masks.

pub fn reset_done_into( &mut self, done_mask: &[bool], out: &mut BatchOutMinimal<'_>, ) -> Result<()>

Reset envs where done_mask is true and fill minimal outputs.

pub fn reset_done_into_i16( &mut self, done_mask: &[bool], out: &mut BatchOutMinimalI16<'_>, ) -> Result<()>

Reset envs where done_mask is true and fill i16 outputs.

pub fn reset_done_into_i16_legal_ids( &mut self, done_mask: &[bool], out: &mut BatchOutMinimalI16LegalIds<'_>, ) -> Result<()>

Reset envs where done_mask is true and fill i16 outputs plus legal-id lists.

Requires output masks to be disabled.

pub fn reset_done_into_nomask( &mut self, done_mask: &[bool], out: &mut BatchOutMinimalNoMask<'_>, ) -> Result<()>

Reset envs where done_mask is true and fill outputs without masks.

pub fn reset_debug_into(&mut self, out: &mut BatchOutDebug<'_>) -> Result<()>

Reset all envs and fill debug outputs.

pub fn reset_indices_debug_into( &mut self, indices: &[usize], out: &mut BatchOutDebug<'_>, ) -> Result<()>

Reset a subset of envs by index and fill debug outputs.

pub fn reset_done_debug_into( &mut self, done_mask: &[bool], out: &mut BatchOutDebug<'_>, ) -> Result<()>

Reset envs where done_mask is true and fill debug outputs.

pub fn reset_engine_error_reset_count(&mut self)

Clear the engine error reset counter.

pub fn auto_reset_on_error_codes_into( &mut self, codes: &[u8], out: &mut BatchOutMinimal<'_>, ) -> Result<usize>

Auto-reset envs with non-zero error codes and fill minimal outputs.

pub fn auto_reset_on_error_codes_into_nomask( &mut self, codes: &[u8], out: &mut BatchOutMinimalNoMask<'_>, ) -> Result<usize>

Auto-reset envs with non-zero error codes and fill outputs without masks.

pub fn reset_i16_overflow_count(&self)

Clear the i16 overflow counter.

pub fn reset_indices_with_episode_seeds_into( &mut self, indices: &[usize], episode_seeds: &[u64], out: &mut BatchOutMinimal<'_>, ) -> Result<()>

Returns Err if any index is out of bounds (>= num_envs). Reset a subset of envs with explicit episode seeds and fill minimal outputs.

pub fn reset_indices_with_episode_seeds_into_i16( &mut self, indices: &[usize], episode_seeds: &[u64], out: &mut BatchOutMinimalI16<'_>, ) -> Result<()>

Returns Err if any index is out of bounds (>= num_envs). Reset a subset of envs with explicit episode seeds and fill i16 outputs.

pub fn reset_indices_with_episode_seeds_into_i16_legal_ids( &mut self, indices: &[usize], episode_seeds: &[u64], out: &mut BatchOutMinimalI16LegalIds<'_>, ) -> Result<()>

Returns Err if any index is out of bounds (>= num_envs). Reset a subset of envs with explicit episode seeds and fill i16 outputs plus legal-id lists.

Requires output masks to be disabled.

pub fn reset_indices_with_episode_seeds_into_nomask( &mut self, indices: &[usize], episode_seeds: &[u64], out: &mut BatchOutMinimalNoMask<'_>, ) -> Result<()>

Returns Err if any index is out of bounds (>= num_envs). Reset a subset of envs with explicit episode seeds and fill outputs without masks.

impl EnvPool

pub fn step_into( &mut self, action_ids: &[u32], out: &mut BatchOutMinimal<'_>, ) -> Result<()>

Step all envs with action ids and fill minimal outputs.

pub fn step_into_i16( &mut self, action_ids: &[u32], out: &mut BatchOutMinimalI16<'_>, ) -> Result<()>

Step all envs with action ids and fill i16 outputs.

pub fn step_into_i16_legal_ids( &mut self, action_ids: &[u32], out: &mut BatchOutMinimalI16LegalIds<'_>, ) -> Result<()>

Step all envs and fill i16 outputs plus legal-id lists.

Requires output masks to be disabled.

pub fn step_into_nomask( &mut self, action_ids: &[u32], out: &mut BatchOutMinimalNoMask<'_>, ) -> Result<()>

Step all envs and fill outputs without masks.

pub fn step_first_legal_into_i16_legal_ids( &mut self, actions: &mut [u32], out: &mut BatchOutMinimalI16LegalIds<'_>, ) -> Result<()>

Step using the first legal action per env (i16 + legal ids).

pub fn step_sample_legal_action_ids_uniform_into_i16_legal_ids( &mut self, seeds: &[u64], actions: &mut [u32], out: &mut BatchOutMinimalI16LegalIds<'_>, ) -> Result<()>

Step using uniformly sampled legal actions (i16 + legal ids).

pub fn step_debug_into( &mut self, action_ids: &[u32], out: &mut BatchOutDebug<'_>, ) -> Result<()>

Step all envs and fill debug outputs.

pub fn step_first_legal_into( &mut self, actions: &mut [u32], out: &mut BatchOutMinimal<'_>, ) -> Result<()>

Step using the first legal action per env.

pub fn step_first_legal_into_i16( &mut self, actions: &mut [u32], out: &mut BatchOutMinimalI16<'_>, ) -> Result<()>

Step using the first legal action per env (i16 outputs).

pub fn step_first_legal_into_nomask( &mut self, actions: &mut [u32], out: &mut BatchOutMinimalNoMask<'_>, ) -> Result<()>

Step using the first legal action per env (no masks).

pub fn step_sample_legal_action_ids_uniform_into( &mut self, seeds: &[u64], actions: &mut [u32], out: &mut BatchOutMinimal<'_>, ) -> Result<()>

Step using uniformly sampled legal actions.

pub fn step_sample_legal_action_ids_uniform_into_i16( &mut self, seeds: &[u64], actions: &mut [u32], out: &mut BatchOutMinimalI16<'_>, ) -> Result<()>

Step using uniformly sampled legal actions (i16 outputs).

pub fn step_sample_legal_action_ids_uniform_into_nomask( &mut self, seeds: &[u64], actions: &mut [u32], out: &mut BatchOutMinimalNoMask<'_>, ) -> Result<()>

Step using uniformly sampled legal actions (no masks).

pub fn rollout_first_legal_into( &mut self, steps: usize, out: &mut BatchOutTrajectory<'_>, ) -> Result<()>

Roll out a trajectory using first legal actions.

pub fn rollout_first_legal_into_i16( &mut self, steps: usize, out: &mut BatchOutTrajectoryI16<'_>, ) -> Result<()>

Roll out a trajectory using first legal actions (i16 outputs).

pub fn rollout_first_legal_into_i16_legal_ids( &mut self, steps: usize, out: &mut BatchOutTrajectoryI16LegalIds<'_>, ) -> Result<()>

Roll out a trajectory using first legal actions (i16 + legal ids).

Requires output masks to be disabled.

pub fn rollout_first_legal_into_nomask( &mut self, steps: usize, out: &mut BatchOutTrajectoryNoMask<'_>, ) -> Result<()>

Roll out a trajectory using first legal actions (no masks).

pub fn rollout_sample_legal_action_ids_uniform_into( &mut self, steps: usize, seeds: &[u64], out: &mut BatchOutTrajectory<'_>, ) -> Result<()>

Roll out a trajectory using uniformly sampled legal actions.

pub fn rollout_sample_legal_action_ids_uniform_into_i16( &mut self, steps: usize, seeds: &[u64], out: &mut BatchOutTrajectoryI16<'_>, ) -> Result<()>

Roll out a trajectory using uniformly sampled legal actions (i16 outputs).

pub fn rollout_sample_legal_action_ids_uniform_into_i16_legal_ids( &mut self, steps: usize, seeds: &[u64], out: &mut BatchOutTrajectoryI16LegalIds<'_>, ) -> Result<()>

Roll out a trajectory using uniformly sampled legal actions (i16 + legal ids).

Requires output masks to be disabled.

pub fn rollout_sample_legal_action_ids_uniform_into_nomask( &mut self, steps: usize, seeds: &[u64], out: &mut BatchOutTrajectoryNoMask<'_>, ) -> Result<()>

Roll out a trajectory using uniformly sampled legal actions (no masks).