avila_parallel/
lib.rs

1//! # avila-parallel
2//!
3//! Data parallelism library for AVL Platform.
4//!
5//! ## Features
6//!
7//! - Thread pool with work stealing
8//! - Parallel iterators
9//! - Scoped threads
10//! - Zero overhead abstractions
11//!
12//! ## Quick Start
13//!
14//! ```rust
15//! use avila_parallel::prelude::*;
16//!
17//! let numbers: Vec<i32> = (0..1000).collect();
18//! let sum: i32 = numbers.par_iter().sum();
19//! ```
20
21#![warn(missing_docs)]
22#![warn(clippy::all)]
23
24pub mod thread_pool;
25pub mod parallel;
26pub mod scope;
27pub mod executor;
28pub mod parallel_vec;
29pub mod advanced;
30
31pub use thread_pool::ThreadPool;
32pub use parallel::{ParallelIterator, IntoParallelIterator};
33pub use parallel_vec::{ParallelVec, IntoParallelVec};
34pub use advanced::{parallel_sort, parallel_sort_by, parallel_zip, parallel_chunks, parallel_partition_advanced};
35
36/// Prelude module for convenient imports
37pub mod prelude {
38    pub use crate::parallel::{ParallelIterator, IntoParallelIterator, ParallelSlice, ParallelSliceMut};
39    pub use crate::parallel_vec::{ParallelVec, IntoParallelVec};
40    // Re-export std::thread::scope for convenience
41    pub use std::thread::scope;
42}
43
44/// Version information
45pub const VERSION: &str = env!("CARGO_PKG_VERSION");
46
47// Re-export std::thread::scope directly
48pub use std::thread::scope;
49
50#[cfg(test)]
51mod tests {
52    use super::prelude::*;
53    use super::ThreadPool;
54
55    #[test]
56    fn test_parallel_sum() {
57        let numbers: Vec<i32> = (0..100).collect();
58        let sum: i32 = numbers.par_iter().sum();
59        assert_eq!(sum, 4950);
60    }
61
62    #[test]
63    fn test_parallel_map() {
64        let numbers: Vec<i32> = vec![1, 2, 3, 4, 5];
65        let doubled: Vec<i32> = numbers
66            .par_iter()
67            .map(|&x| x * 2)
68            .collect();
69        assert_eq!(doubled, vec![2, 4, 6, 8, 10]);
70    }
71
72    #[test]
73    fn test_thread_pool() {
74        let pool = ThreadPool::new(2);
75
76        for i in 0..10 {
77            pool.execute(move || {
78                let _result = i * i;
79                // Thread pool executes jobs without returning values
80            });
81        }
82
83        pool.wait();
84    }
85
86    #[test]
87    fn test_parallel_filter() {
88        let numbers: Vec<i32> = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
89        let evens: Vec<i32> = numbers
90            .par_iter()
91            .filter(|&x| x % 2 == 0)
92            .cloned()
93            .collect();
94        assert_eq!(evens, vec![2, 4, 6, 8, 10]);
95    }
96
97    #[test]
98    fn test_parallel_fold() {
99        let numbers: Vec<i32> = vec![1, 2, 3, 4, 5];
100        let result: Vec<i32> = numbers
101            .par_iter()
102            .fold(|| 0, |acc, &x| acc + x)
103            .collect();
104        assert_eq!(result.len(), 1);
105        assert_eq!(result[0], 15);
106    }
107
108    #[test]
109    fn test_parallel_reduce() {
110        let numbers: Vec<i32> = vec![1, 2, 3, 4, 5];
111        let result = numbers
112            .par_iter()
113            .cloned()
114            .reduce(|a, b| a + b);
115        assert_eq!(result, Some(15));
116    }
117
118    #[test]
119    fn test_parallel_find_any() {
120        let numbers: Vec<i32> = vec![1, 2, 3, 4, 5];
121        let found = numbers
122            .par_iter()
123            .find_any(|&&x| x > 3);
124        assert!(found.is_some());
125        assert!(*found.unwrap() > 3);
126    }
127
128    #[test]
129    fn test_parallel_all() {
130        let numbers: Vec<i32> = vec![2, 4, 6, 8, 10];
131        let all_even = numbers
132            .par_iter()
133            .all(|&x| x % 2 == 0);
134        assert!(all_even);
135    }
136
137    #[test]
138    fn test_parallel_any() {
139        let numbers: Vec<i32> = vec![1, 3, 5, 7, 8];
140        let has_even = numbers
141            .par_iter()
142            .any(|&x| x % 2 == 0);
143        assert!(has_even);
144    }
145
146    #[test]
147    fn test_parallel_cloned() {
148        let numbers: Vec<i32> = vec![1, 2, 3, 4, 5];
149        let doubled: Vec<i32> = numbers
150            .par_iter()
151            .cloned()
152            .map(|x| x * 2)
153            .collect();
154        assert_eq!(doubled, vec![2, 4, 6, 8, 10]);
155    }
156
157    #[test]
158    fn test_parallel_iter_mut() {
159        let mut numbers: Vec<i32> = vec![1, 2, 3, 4, 5];
160        numbers
161            .par_iter_mut()
162            .for_each(|x| *x *= 2);
163        assert_eq!(numbers, vec![2, 4, 6, 8, 10]);
164    }
165}
avila_parallel/lib.rs

avila_parallel/
lib.rs
