Struct SafeVariableEnvironment 

pub struct SafeVariableEnvironment<F: Float + Send + Sync> { /* private fields */ }

Thread-safe alternative to VariableEnvironment for global usage and PyTorch-compatible APIs

This wrapper solves the thread safety issues with RefCell-based VariableEnvironment, enabling global autograd environments and multi-threaded gradient computation.

Key Features:

• Thread-safe: Uses Arc<RwLock<>> for shared ownership and concurrent access
• Global-safe: Can be used in static variables and lazy_static
• PyTorch-compatible: Provides backward() API for autograd integration
• Performance: Optimized for multi-threaded gradient computation

Usage Example:

use scirs2_autograd::SafeVariableEnvironment;
use std::sync::Arc;

// Thread-safe operations
let env = SafeVariableEnvironment::new();
let arr = scirs2_core::ndarray::arr2(&[[1.0, 2.0], [3.0, 4.0]]).into_dyn();
let var_id = env.set_variable(arr).expect("Operation failed");
env.backward(var_id).expect("Operation failed");

Implementations

impl<F: Float + Send + Sync> SafeVariableEnvironment<F>

pub fn new() -> Self

Creates a new thread-safe variable environment

pub fn set_variable( &self, array: NdArray<F>, ) -> Result<VariableID, Box<dyn Error + Send + Sync>>

Sets a variable array and returns its ID (thread-safe)

pub fn name_variable<S: AsRef<str>>( &self, name: S, array: NdArray<F>, ) -> Result<VariableID, Box<dyn Error + Send + Sync>>

Names a variable for later lookup (thread-safe)

pub fn get_variable( &self, var_id: VariableID, ) -> Result<NdArray<F>, Box<dyn Error + Send + Sync>>

Gets a copy of a variable array (thread-safe)

pub fn backward( &self, output_var: VariableID, ) -> Result<(), Box<dyn Error + Send + Sync>>

PyTorch-compatible backward pass implementation

This provides the backward() API that ToRSh expects for autograd integration. Unlike the graph-based execution model, this provides direct tensor-level backward passes.

pub fn parallel_backward_pass( &self, outputs: &[VariableID], _inputs: &[VariableID], ) -> Result<Vec<Option<NdArray<F>>>, Box<dyn Error + Send + Sync>>

High-performance parallel gradient computation

This addresses ToRSh’s requirement for parallel backward pass implementation targeting 10-50x speedup for gradient computation.

pub fn run<R>( &self, func: impl FnOnce(&VariableEnvironment<F>) -> R, ) -> Result<R, Box<dyn Error + Send + Sync>>

Execute operations within the environment context (thread-safe)

pub fn len(&self) -> Result<usize, Box<dyn Error + Send + Sync>>

Get the number of variables in the environment (thread-safe)

pub fn is_empty(&self) -> Result<bool, Box<dyn Error + Send + Sync>>

Check if the environment is empty (thread-safe)

Trait Implementations

impl<F: Clone + Float + Send + Sync> Clone for SafeVariableEnvironment<F>

fn clone(&self) -> SafeVariableEnvironment<F>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<F: Float + Send + Sync> Default for SafeVariableEnvironment<F>

fn default() -> Self

Returns the “default value” for a type.

impl<F: Float + Send + Sync> Send for SafeVariableEnvironment<F>

Implement Send + Sync for thread safety

impl<F: Float + Send + Sync> Sync for SafeVariableEnvironment<F>