scirs2-linalg 0.4.2

Linear algebra module for SciRS2 (scirs2-linalg)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

//! Distributed linear algebra operations
//!
//! This module provides distributed implementations of linear algebra operations
//! that can scale across multiple nodes or computing devices. It integrates with
//! the SIMD vectorization framework and provides efficient communication primitives
//! for distributed computing workloads.
//!
//! # Features
//!
//! - **Distributed matrix operations**: Matrix multiplication, decompositions, and solvers
//! - **Load balancing**: Automatic work distribution and load balancing across nodes
//! - **Communication optimization**: Efficient data transfer with minimal overhead
//! - **SIMD integration**: Leverages SIMD operations for maximum performance per node
//! - **Fault tolerance**: Graceful handling of node failures and recovery
//! - **Memory efficiency**: Optimized memory usage for large-scale computations
//!
//! # Architecture
//!
//! The distributed computing framework consists of several layers:
//!
//! 1. **Communication Layer**: Handles data transfer between nodes
//! 2. **Distribution Layer**: Manages data partitioning and work distribution
//! 3. **Computation Layer**: Executes local computations using SIMD acceleration
//! 4. **Coordination Layer**: Synchronizes operations across nodes
//!
//! # Example
//!
//! ```rust
//! use scirs2_linalg::distributed::{DistributedConfig, DistributedMatrix};
//! use scirs2_core::ndarray::Array2;
//!
//! // Create a distributed matrix
//! let matrix = Array2::from_shape_fn((1000, 1000), |(i, j)| (i + j) as f64);
//! let config = DistributedConfig::default().with_num_nodes(4);
//! let distmatrix = DistributedMatrix::from_local(matrix, config)?;
//!
//! // Perform distributed matrix multiplication
//! let result = distmatrix.distributed_matmul(&distmatrix)?;
//!
//! // Gather results back to local matrix
//! let local_result = result.gather()?;
//! ```

// Core modules
pub mod algorithms;
pub mod communication;
pub mod distribution;
pub mod computation;
pub mod coordination;
pub mod matrix;
pub mod solvers;
pub mod decomposition;
pub mod mpi;

// New modular components
pub mod config;
pub mod stats;
pub mod load_balancer;
pub mod fault_tolerance;
pub mod redundancy;
pub mod monitoring;
pub mod capacity_planning;
pub mod topology;
pub mod context;
pub mod ops;
pub mod framework;

// Re-export main types for convenience
pub use communication::{CommunicationBackend, DistributedCommunicator, MessageTag};
pub use coordination::{DistributedCoordinator, SynchronizationBarrier};
pub use distribution::{DataDistribution, DistributionStrategy, LoadBalancer};
pub use matrix::{DistributedMatrix, DistributedVector};
pub use mpi::{
    MPIBackend, MPIConfig, MPIImplementation, BufferStrategy, CollectiveHints,
    MPIErrorHandling, MPIPerformanceTuning, MPICommunicator
};

// Re-export new modular components
pub use config::{DistributedConfig, CompressionConfig, CompressionAlgorithm};
pub use stats::DistributedStats;
pub use load_balancer::{AdaptiveLoadBalancer, LoadPredictionModel, WorkloadType};
pub use fault_tolerance::{FaultToleranceManager, NodeHealthMonitor, CheckpointManager, RecoveryStrategy};
pub use redundancy::{RedundancyManager, RedundancyPolicy};
pub use monitoring::{ResourceMonitor, MetricsCollector, AlertSystem};
pub use capacity_planning::{CapacityPlanner, DemandForecastModel};
pub use topology::{NetworkTopologyAnalyzer, TopologySnapshot};
pub use context::{DistributedContext, initialize_distributed, finalize_distributed};
pub use ops::DistributedLinalgOps;
pub use framework::AdvancedDistributedFramework;

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_distributed_config() {
        let config = DistributedConfig::default()
            .with_num_nodes(4)
            .with_node_rank(0)
            .with_blocksize(512)
            .with_simd(true);

        assert_eq!(config.num_nodes, 4);
        assert_eq!(config.node_rank, 0);
        assert_eq!(config.blocksize, 512);
        assert!(config.enable_simd);
    }

    #[test]
    fn test_compression_config() {
        let compression_config = CompressionConfig::default();
        assert_eq!(compression_config.algorithm, CompressionAlgorithm::LZ4);
    }

    #[test]
    fn test_distributed_stats() {
        let mut stats = DistributedStats::new();

        stats.record_communication(1024, 10);
        stats.record_computation(50);

        assert_eq!(stats.bytes_transferred, 1024);
        assert_eq!(stats.comm_time_ms, 10);
        assert_eq!(stats.compute_time_ms, 50);
        assert_eq!(stats.comm_events, 1);
        assert_eq!(stats.operations_count, 1);

        assert_eq!(stats.comm_compute_ratio(), 0.2);
        assert_eq!(stats.bandwidth_utilization(), 102.4);
    }
}