avx_parallel/
lib.rs

1//! # avx-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 avx_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;
30pub mod work_stealing;
31pub mod simd;
32pub mod config;
33pub mod lockfree;
34pub mod pipeline;
35pub mod adaptive;
36pub mod memory;
37
38pub use thread_pool::ThreadPool;
39pub use parallel::{ParallelIterator, IntoParallelIterator};
40pub use parallel_vec::{ParallelVec, IntoParallelVec};
41pub use advanced::{parallel_sort, parallel_sort_by, parallel_zip, parallel_chunks, parallel_partition_advanced};
42pub use work_stealing::{WorkStealingPool, work_stealing_map};
43pub use config::{ThreadPoolConfig, set_global_config, get_global_config};
44pub use lockfree::{lockfree_count, lockfree_any, lockfree_all, AtomicCounter};
45pub use pipeline::{MapReduce, BatchProcessor};
46pub use adaptive::{AdaptiveExecutor, speculative_execute, hierarchical_map, cache_aware_map};
47pub use memory::{parallel_transform_inplace, parallel_fold_efficient, parallel_iter_nocopy};
48
49/// Prelude module for convenient imports
50pub mod prelude {
51    pub use crate::parallel::{ParallelIterator, IntoParallelIterator, ParallelSlice, ParallelSliceMut};
52    pub use crate::parallel_vec::{ParallelVec, IntoParallelVec};
53    pub use crate::lockfree::{lockfree_count, lockfree_any, lockfree_all};
54    pub use crate::adaptive::{AdaptiveExecutor, speculative_execute};
55    pub use crate::memory::{parallel_transform_inplace, parallel_iter_nocopy};
56    // Re-export std::thread::scope for convenience
57    pub use std::thread::scope;
58}
59
60/// Version information
61pub const VERSION: &str = env!("CARGO_PKG_VERSION");
62
63// Re-export std::thread::scope directly
64pub use std::thread::scope;
65
66#[cfg(test)]
67mod tests {
68    use super::prelude::*;
69    use super::ThreadPool;
70
71    #[test]
72    fn test_parallel_sum() {
73        let numbers: Vec<i32> = (0..100).collect();
74        let sum: i32 = numbers.par_iter().sum();
75        assert_eq!(sum, 4950);
76    }
77
78    #[test]
79    fn test_parallel_map() {
80        let numbers: Vec<i32> = vec![1, 2, 3, 4, 5];
81        let doubled: Vec<i32> = numbers
82            .par_iter()
83            .map(|&x| x * 2)
84            .collect();
85        assert_eq!(doubled, vec![2, 4, 6, 8, 10]);
86    }
87
88    #[test]
89    fn test_thread_pool() {
90        let pool = ThreadPool::new(2);
91
92        for i in 0..10 {
93            pool.execute(move || {
94                let _result = i * i;
95                // Thread pool executes jobs without returning values
96            });
97        }
98
99        pool.wait();
100    }
101
102    #[test]
103    fn test_parallel_filter() {
104        let numbers: Vec<i32> = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
105        let evens: Vec<i32> = numbers
106            .par_iter()
107            .filter(|&x| x % 2 == 0)
108            .cloned()
109            .collect();
110        assert_eq!(evens, vec![2, 4, 6, 8, 10]);
111    }
112
113    #[test]
114    fn test_parallel_fold() {
115        let numbers: Vec<i32> = vec![1, 2, 3, 4, 5];
116        let result: Vec<i32> = numbers
117            .par_iter()
118            .fold(|| 0, |acc, &x| acc + x)
119            .collect();
120        assert_eq!(result.len(), 1);
121        assert_eq!(result[0], 15);
122    }
123
124    #[test]
125    fn test_parallel_reduce() {
126        let numbers: Vec<i32> = vec![1, 2, 3, 4, 5];
127        let result = numbers
128            .par_iter()
129            .cloned()
130            .reduce(|a, b| a + b);
131        assert_eq!(result, Some(15));
132    }
133
134    #[test]
135    fn test_parallel_find_any() {
136        let numbers: Vec<i32> = vec![1, 2, 3, 4, 5];
137        let found = numbers
138            .par_iter()
139            .find_any(|&&x| x > 3);
140        assert!(found.is_some());
141        assert!(*found.unwrap() > 3);
142    }
143
144    #[test]
145    fn test_parallel_all() {
146        let numbers: Vec<i32> = vec![2, 4, 6, 8, 10];
147        let all_even = numbers
148            .par_iter()
149            .all(|&x| x % 2 == 0);
150        assert!(all_even);
151    }
152
153    #[test]
154    fn test_parallel_any() {
155        let numbers: Vec<i32> = vec![1, 3, 5, 7, 8];
156        let has_even = numbers
157            .par_iter()
158            .any(|&x| x % 2 == 0);
159        assert!(has_even);
160    }
161
162    #[test]
163    fn test_parallel_cloned() {
164        let numbers: Vec<i32> = vec![1, 2, 3, 4, 5];
165        let doubled: Vec<i32> = numbers
166            .par_iter()
167            .cloned()
168            .map(|x| x * 2)
169            .collect();
170        assert_eq!(doubled, vec![2, 4, 6, 8, 10]);
171    }
172
173    #[test]
174    fn test_parallel_iter_mut() {
175        let mut numbers: Vec<i32> = vec![1, 2, 3, 4, 5];
176        numbers
177            .par_iter_mut()
178            .for_each(|x| *x *= 2);
179        assert_eq!(numbers, vec![2, 4, 6, 8, 10]);
180    }
181}
182
183
184
185
186
avx_parallel/lib.rs

avx_parallel/
lib.rs
