ConcurrentBatchProcessor

html_translation_lib::pipeline::concurrent_batch

Struct ConcurrentBatchProcessor 

Source 
pub struct ConcurrentBatchProcessor { /* private fields */ }
Expand description

并发批处理器

Implementations§

Source§

impl ConcurrentBatchProcessor

Source

pub fn new( config: BatchConfig, memory_manager: Arc<GlobalMemoryManager>, ) -> Self

创建新的并发批处理器

Examples found in repository?
examples/performance_test.rs (lines 153-156)
51async fn main() -> Result<(), Box<dyn std::error::Error>> {
52    println!("🚀 HTML翻译库性能测试\n");
53    
54    let large_html = generate_large_html();
55    let dom = parse_html(&large_html);
56    
57    println!("📊 测试数据:");
58    println!("  - HTML大小: {} KB", large_html.len() / 1024);
59    println!("  - 包含 ~5000 个文本元素\n");
60    
61    // 1. DOM遍历性能测试
62    println!("🔍 DOM遍历性能对比:");
63    
64    // 原始递归收集器
65    let start = Instant::now();
66    let original_collector = TextCollector::new();
67    let original_items = original_collector.collect_from_dom(&dom)?;
68    let original_time = start.elapsed();
69    println!("  - 原始递归收集器: {}ms, 收集到 {} 项", 
70             original_time.as_millis(), original_items.len());
71    
72    // 优化的迭代收集器
73    let start = Instant::now();
74    let mut optimized_collector = OptimizedTextCollector::new();
75    let optimized_items = optimized_collector.collect_from_dom_optimized(&dom)?;
76    let optimized_time = start.elapsed();
77    println!("  - 优化迭代收集器: {}ms, 收集到 {} 项", 
78             optimized_time.as_millis(), optimized_items.len());
79    
80    let speedup = original_time.as_millis() as f64 / optimized_time.as_millis() as f64;
81    println!("  ✨ 性能提升: {:.2}x 倍速\n", speedup);
82    
83    // 2. 内存管理测试
84    println!("💾 内存管理优化:");
85    let memory_manager = Arc::new(GlobalMemoryManager::new());
86    
87    // 测试字符串池效率
88    let start = Instant::now();
89    let mut test_strings = Vec::new();
90    for i in 0..1000 {
91        let s = memory_manager.acquire_string(50);
92        test_strings.push(format!("Test string {}", i));
93    }
94    
95    for s in test_strings {
96        memory_manager.release_string(s);
97    }
98    let pool_time = start.elapsed();
99    
100    // 获取内存统计
101    let (pool_stats, _) = memory_manager.get_pool_stats();
102    println!("  - 字符串池操作: {}ms", pool_time.as_millis());
103    println!("  - 池大小: 小型={}, 大型={}, 总容量={}KB", 
104             pool_stats.small_pool_size,
105             pool_stats.large_pool_size, 
106             pool_stats.total_capacity / 1024);
107    
108    // 3. 智能缓存测试
109    println!("\n🧠 智能缓存性能:");
110    use html_translation_lib::config::TranslationConfig;
111    
112    let config = TranslationConfig::new()
113        .target_language("zh")
114        .api_url("http://example.com/translate");
115    
116    let mut cache_manager = SmartCacheManager::new(&config).await?;
117    
118    let start = Instant::now();
119    
120    // 模拟缓存操作
121    for i in 0..500 {
122        let key = format!("text_{}", i % 100); // 重复键以测试缓存命中
123        let value = format!("translation_{}", i);
124        cache_manager.set(&key, value).await?;
125    }
126    
127    // 测试缓存命中
128    let mut hits = 0;
129    for i in 0..100 {
130        let key = format!("text_{}", i);
131        if cache_manager.get(&key).await?.is_some() {
132            hits += 1;
133        }
134    }
135    
136    let cache_time = start.elapsed();
137    let cache_stats = cache_manager.stats();
138    
139    println!("  - 缓存操作时间: {}ms", cache_time.as_millis());
140    println!("  - 缓存命中数: {} / 100", hits);
141    println!("  - L1命中率: {:.1}%", cache_stats.l1_hit_rate() * 100.0);
142    println!("  - 总命中率: {:.1}%", cache_stats.hit_rate() * 100.0);
143    
144    // 4. 并发批处理测试
145    println!("\n⚡ 并发批处理性能:");
146    let batch_config = BatchConfig {
147        batch_size: 20,
148        max_concurrency: 4,
149        timeout_duration: std::time::Duration::from_secs(10),
150        ..Default::default()
151    };
152    
153    let batch_processor = ConcurrentBatchProcessor::new(
154        batch_config, 
155        Arc::clone(&memory_manager)
156    );
157    
158    // 准备测试文本
159    let test_texts: Vec<String> = (0..200)
160        .map(|i| format!("Test text number {}", i))
161        .collect();
162    
163    let start = Instant::now();
164    
165    // 提交批处理任务
166    let mut task_ids = Vec::new();
167    for chunk in test_texts.chunks(50) {
168        let task_id = batch_processor.submit_batch(
169            chunk.to_vec(), 
170            Priority::Normal
171        ).await?;
172        task_ids.push(task_id);
173    }
174    
175    // 模拟翻译函数
176    async fn mock_translate(texts: Vec<String>) -> html_translation_lib::error::TranslationResult<Vec<String>> {
177        tokio::time::sleep(std::time::Duration::from_millis(10)).await;
178        Ok(texts.into_iter().map(|t| format!("翻译_{}", t)).collect())
179    }
180    
181    // 处理队列
182    let _results = batch_processor.process_queue(mock_translate).await?;
183    let batch_time = start.elapsed();
184    
185    let batch_stats = batch_processor.get_stats().await;
186    let queue_status = batch_processor.get_queue_status();
187    
188    println!("  - 批处理总时间: {}ms", batch_time.as_millis());
189    println!("  - 处理成功率: {:.1}%", batch_stats.success_rate() * 100.0);
190    println!("  - 平均处理时间: {}ms", batch_stats.average_processing_time().as_millis());
191    println!("  - 吞吐量: {:.1} 任务/秒", batch_stats.throughput());
192    println!("  - 队列剩余: {} 任务", queue_status.total_tasks);
193    
194    // 5. 总结
195    println!("\n📈 性能优化总结:");
196    println!("  ✅ DOM遍历优化: {:.1}x 性能提升", speedup);
197    println!("  ✅ 内存池管理: 减少 GC 压力");
198    println!("  ✅ 智能缓存: {:.1}% 命中率", cache_stats.hit_rate() * 100.0);
199    println!("  ✅ 并发批处理: {:.1}% 成功率", batch_stats.success_rate() * 100.0);
200    println!("\n🎉 所有性能优化测试完成!");
201    
202    Ok(())
203}
Source

pub async fn submit_batch( &self, texts: Vec<String>, priority: Priority, ) -> TranslationResult<u64>

提交批处理任务

Examples found in repository?
examples/performance_test.rs (lines 168-171)
51async fn main() -> Result<(), Box<dyn std::error::Error>> {
52    println!("🚀 HTML翻译库性能测试\n");
53    
54    let large_html = generate_large_html();
55    let dom = parse_html(&large_html);
56    
57    println!("📊 测试数据:");
58    println!("  - HTML大小: {} KB", large_html.len() / 1024);
59    println!("  - 包含 ~5000 个文本元素\n");
60    
61    // 1. DOM遍历性能测试
62    println!("🔍 DOM遍历性能对比:");
63    
64    // 原始递归收集器
65    let start = Instant::now();
66    let original_collector = TextCollector::new();
67    let original_items = original_collector.collect_from_dom(&dom)?;
68    let original_time = start.elapsed();
69    println!("  - 原始递归收集器: {}ms, 收集到 {} 项", 
70             original_time.as_millis(), original_items.len());
71    
72    // 优化的迭代收集器
73    let start = Instant::now();
74    let mut optimized_collector = OptimizedTextCollector::new();
75    let optimized_items = optimized_collector.collect_from_dom_optimized(&dom)?;
76    let optimized_time = start.elapsed();
77    println!("  - 优化迭代收集器: {}ms, 收集到 {} 项", 
78             optimized_time.as_millis(), optimized_items.len());
79    
80    let speedup = original_time.as_millis() as f64 / optimized_time.as_millis() as f64;
81    println!("  ✨ 性能提升: {:.2}x 倍速\n", speedup);
82    
83    // 2. 内存管理测试
84    println!("💾 内存管理优化:");
85    let memory_manager = Arc::new(GlobalMemoryManager::new());
86    
87    // 测试字符串池效率
88    let start = Instant::now();
89    let mut test_strings = Vec::new();
90    for i in 0..1000 {
91        let s = memory_manager.acquire_string(50);
92        test_strings.push(format!("Test string {}", i));
93    }
94    
95    for s in test_strings {
96        memory_manager.release_string(s);
97    }
98    let pool_time = start.elapsed();
99    
100    // 获取内存统计
101    let (pool_stats, _) = memory_manager.get_pool_stats();
102    println!("  - 字符串池操作: {}ms", pool_time.as_millis());
103    println!("  - 池大小: 小型={}, 大型={}, 总容量={}KB", 
104             pool_stats.small_pool_size,
105             pool_stats.large_pool_size, 
106             pool_stats.total_capacity / 1024);
107    
108    // 3. 智能缓存测试
109    println!("\n🧠 智能缓存性能:");
110    use html_translation_lib::config::TranslationConfig;
111    
112    let config = TranslationConfig::new()
113        .target_language("zh")
114        .api_url("http://example.com/translate");
115    
116    let mut cache_manager = SmartCacheManager::new(&config).await?;
117    
118    let start = Instant::now();
119    
120    // 模拟缓存操作
121    for i in 0..500 {
122        let key = format!("text_{}", i % 100); // 重复键以测试缓存命中
123        let value = format!("translation_{}", i);
124        cache_manager.set(&key, value).await?;
125    }
126    
127    // 测试缓存命中
128    let mut hits = 0;
129    for i in 0..100 {
130        let key = format!("text_{}", i);
131        if cache_manager.get(&key).await?.is_some() {
132            hits += 1;
133        }
134    }
135    
136    let cache_time = start.elapsed();
137    let cache_stats = cache_manager.stats();
138    
139    println!("  - 缓存操作时间: {}ms", cache_time.as_millis());
140    println!("  - 缓存命中数: {} / 100", hits);
141    println!("  - L1命中率: {:.1}%", cache_stats.l1_hit_rate() * 100.0);
142    println!("  - 总命中率: {:.1}%", cache_stats.hit_rate() * 100.0);
143    
144    // 4. 并发批处理测试
145    println!("\n⚡ 并发批处理性能:");
146    let batch_config = BatchConfig {
147        batch_size: 20,
148        max_concurrency: 4,
149        timeout_duration: std::time::Duration::from_secs(10),
150        ..Default::default()
151    };
152    
153    let batch_processor = ConcurrentBatchProcessor::new(
154        batch_config, 
155        Arc::clone(&memory_manager)
156    );
157    
158    // 准备测试文本
159    let test_texts: Vec<String> = (0..200)
160        .map(|i| format!("Test text number {}", i))
161        .collect();
162    
163    let start = Instant::now();
164    
165    // 提交批处理任务
166    let mut task_ids = Vec::new();
167    for chunk in test_texts.chunks(50) {
168        let task_id = batch_processor.submit_batch(
169            chunk.to_vec(), 
170            Priority::Normal
171        ).await?;
172        task_ids.push(task_id);
173    }
174    
175    // 模拟翻译函数
176    async fn mock_translate(texts: Vec<String>) -> html_translation_lib::error::TranslationResult<Vec<String>> {
177        tokio::time::sleep(std::time::Duration::from_millis(10)).await;
178        Ok(texts.into_iter().map(|t| format!("翻译_{}", t)).collect())
179    }
180    
181    // 处理队列
182    let _results = batch_processor.process_queue(mock_translate).await?;
183    let batch_time = start.elapsed();
184    
185    let batch_stats = batch_processor.get_stats().await;
186    let queue_status = batch_processor.get_queue_status();
187    
188    println!("  - 批处理总时间: {}ms", batch_time.as_millis());
189    println!("  - 处理成功率: {:.1}%", batch_stats.success_rate() * 100.0);
190    println!("  - 平均处理时间: {}ms", batch_stats.average_processing_time().as_millis());
191    println!("  - 吞吐量: {:.1} 任务/秒", batch_stats.throughput());
192    println!("  - 队列剩余: {} 任务", queue_status.total_tasks);
193    
194    // 5. 总结
195    println!("\n📈 性能优化总结:");
196    println!("  ✅ DOM遍历优化: {:.1}x 性能提升", speedup);
197    println!("  ✅ 内存池管理: 减少 GC 压力");
198    println!("  ✅ 智能缓存: {:.1}% 命中率", cache_stats.hit_rate() * 100.0);
199    println!("  ✅ 并发批处理: {:.1}% 成功率", batch_stats.success_rate() * 100.0);
200    println!("\n🎉 所有性能优化测试完成!");
201    
202    Ok(())
203}
Source

pub async fn process_queue<F, Fut>( &self, translation_fn: F, ) -> TranslationResult<Vec<BatchResult>>
where F: Fn(Vec<String>) -> Fut + Send + Sync + Clone + 'static, Fut: Future<Output = TranslationResult<Vec<String>>> + Send + 'static,

并行处理批次队列

Examples found in repository?
examples/performance_test.rs (line 182)
51async fn main() -> Result<(), Box<dyn std::error::Error>> {
52    println!("🚀 HTML翻译库性能测试\n");
53    
54    let large_html = generate_large_html();
55    let dom = parse_html(&large_html);
56    
57    println!("📊 测试数据:");
58    println!("  - HTML大小: {} KB", large_html.len() / 1024);
59    println!("  - 包含 ~5000 个文本元素\n");
60    
61    // 1. DOM遍历性能测试
62    println!("🔍 DOM遍历性能对比:");
63    
64    // 原始递归收集器
65    let start = Instant::now();
66    let original_collector = TextCollector::new();
67    let original_items = original_collector.collect_from_dom(&dom)?;
68    let original_time = start.elapsed();
69    println!("  - 原始递归收集器: {}ms, 收集到 {} 项", 
70             original_time.as_millis(), original_items.len());
71    
72    // 优化的迭代收集器
73    let start = Instant::now();
74    let mut optimized_collector = OptimizedTextCollector::new();
75    let optimized_items = optimized_collector.collect_from_dom_optimized(&dom)?;
76    let optimized_time = start.elapsed();
77    println!("  - 优化迭代收集器: {}ms, 收集到 {} 项", 
78             optimized_time.as_millis(), optimized_items.len());
79    
80    let speedup = original_time.as_millis() as f64 / optimized_time.as_millis() as f64;
81    println!("  ✨ 性能提升: {:.2}x 倍速\n", speedup);
82    
83    // 2. 内存管理测试
84    println!("💾 内存管理优化:");
85    let memory_manager = Arc::new(GlobalMemoryManager::new());
86    
87    // 测试字符串池效率
88    let start = Instant::now();
89    let mut test_strings = Vec::new();
90    for i in 0..1000 {
91        let s = memory_manager.acquire_string(50);
92        test_strings.push(format!("Test string {}", i));
93    }
94    
95    for s in test_strings {
96        memory_manager.release_string(s);
97    }
98    let pool_time = start.elapsed();
99    
100    // 获取内存统计
101    let (pool_stats, _) = memory_manager.get_pool_stats();
102    println!("  - 字符串池操作: {}ms", pool_time.as_millis());
103    println!("  - 池大小: 小型={}, 大型={}, 总容量={}KB", 
104             pool_stats.small_pool_size,
105             pool_stats.large_pool_size, 
106             pool_stats.total_capacity / 1024);
107    
108    // 3. 智能缓存测试
109    println!("\n🧠 智能缓存性能:");
110    use html_translation_lib::config::TranslationConfig;
111    
112    let config = TranslationConfig::new()
113        .target_language("zh")
114        .api_url("http://example.com/translate");
115    
116    let mut cache_manager = SmartCacheManager::new(&config).await?;
117    
118    let start = Instant::now();
119    
120    // 模拟缓存操作
121    for i in 0..500 {
122        let key = format!("text_{}", i % 100); // 重复键以测试缓存命中
123        let value = format!("translation_{}", i);
124        cache_manager.set(&key, value).await?;
125    }
126    
127    // 测试缓存命中
128    let mut hits = 0;
129    for i in 0..100 {
130        let key = format!("text_{}", i);
131        if cache_manager.get(&key).await?.is_some() {
132            hits += 1;
133        }
134    }
135    
136    let cache_time = start.elapsed();
137    let cache_stats = cache_manager.stats();
138    
139    println!("  - 缓存操作时间: {}ms", cache_time.as_millis());
140    println!("  - 缓存命中数: {} / 100", hits);
141    println!("  - L1命中率: {:.1}%", cache_stats.l1_hit_rate() * 100.0);
142    println!("  - 总命中率: {:.1}%", cache_stats.hit_rate() * 100.0);
143    
144    // 4. 并发批处理测试
145    println!("\n⚡ 并发批处理性能:");
146    let batch_config = BatchConfig {
147        batch_size: 20,
148        max_concurrency: 4,
149        timeout_duration: std::time::Duration::from_secs(10),
150        ..Default::default()
151    };
152    
153    let batch_processor = ConcurrentBatchProcessor::new(
154        batch_config, 
155        Arc::clone(&memory_manager)
156    );
157    
158    // 准备测试文本
159    let test_texts: Vec<String> = (0..200)
160        .map(|i| format!("Test text number {}", i))
161        .collect();
162    
163    let start = Instant::now();
164    
165    // 提交批处理任务
166    let mut task_ids = Vec::new();
167    for chunk in test_texts.chunks(50) {
168        let task_id = batch_processor.submit_batch(
169            chunk.to_vec(), 
170            Priority::Normal
171        ).await?;
172        task_ids.push(task_id);
173    }
174    
175    // 模拟翻译函数
176    async fn mock_translate(texts: Vec<String>) -> html_translation_lib::error::TranslationResult<Vec<String>> {
177        tokio::time::sleep(std::time::Duration::from_millis(10)).await;
178        Ok(texts.into_iter().map(|t| format!("翻译_{}", t)).collect())
179    }
180    
181    // 处理队列
182    let _results = batch_processor.process_queue(mock_translate).await?;
183    let batch_time = start.elapsed();
184    
185    let batch_stats = batch_processor.get_stats().await;
186    let queue_status = batch_processor.get_queue_status();
187    
188    println!("  - 批处理总时间: {}ms", batch_time.as_millis());
189    println!("  - 处理成功率: {:.1}%", batch_stats.success_rate() * 100.0);
190    println!("  - 平均处理时间: {}ms", batch_stats.average_processing_time().as_millis());
191    println!("  - 吞吐量: {:.1} 任务/秒", batch_stats.throughput());
192    println!("  - 队列剩余: {} 任务", queue_status.total_tasks);
193    
194    // 5. 总结
195    println!("\n📈 性能优化总结:");
196    println!("  ✅ DOM遍历优化: {:.1}x 性能提升", speedup);
197    println!("  ✅ 内存池管理: 减少 GC 压力");
198    println!("  ✅ 智能缓存: {:.1}% 命中率", cache_stats.hit_rate() * 100.0);
199    println!("  ✅ 并发批处理: {:.1}% 成功率", batch_stats.success_rate() * 100.0);
200    println!("\n🎉 所有性能优化测试完成!");
201    
202    Ok(())
203}
Source

pub async fn get_stats(&self) -> BatchProcessingStats

获取处理统计信息

Examples found in repository?
examples/performance_test.rs (line 185)
51async fn main() -> Result<(), Box<dyn std::error::Error>> {
52    println!("🚀 HTML翻译库性能测试\n");
53    
54    let large_html = generate_large_html();
55    let dom = parse_html(&large_html);
56    
57    println!("📊 测试数据:");
58    println!("  - HTML大小: {} KB", large_html.len() / 1024);
59    println!("  - 包含 ~5000 个文本元素\n");
60    
61    // 1. DOM遍历性能测试
62    println!("🔍 DOM遍历性能对比:");
63    
64    // 原始递归收集器
65    let start = Instant::now();
66    let original_collector = TextCollector::new();
67    let original_items = original_collector.collect_from_dom(&dom)?;
68    let original_time = start.elapsed();
69    println!("  - 原始递归收集器: {}ms, 收集到 {} 项", 
70             original_time.as_millis(), original_items.len());
71    
72    // 优化的迭代收集器
73    let start = Instant::now();
74    let mut optimized_collector = OptimizedTextCollector::new();
75    let optimized_items = optimized_collector.collect_from_dom_optimized(&dom)?;
76    let optimized_time = start.elapsed();
77    println!("  - 优化迭代收集器: {}ms, 收集到 {} 项", 
78             optimized_time.as_millis(), optimized_items.len());
79    
80    let speedup = original_time.as_millis() as f64 / optimized_time.as_millis() as f64;
81    println!("  ✨ 性能提升: {:.2}x 倍速\n", speedup);
82    
83    // 2. 内存管理测试
84    println!("💾 内存管理优化:");
85    let memory_manager = Arc::new(GlobalMemoryManager::new());
86    
87    // 测试字符串池效率
88    let start = Instant::now();
89    let mut test_strings = Vec::new();
90    for i in 0..1000 {
91        let s = memory_manager.acquire_string(50);
92        test_strings.push(format!("Test string {}", i));
93    }
94    
95    for s in test_strings {
96        memory_manager.release_string(s);
97    }
98    let pool_time = start.elapsed();
99    
100    // 获取内存统计
101    let (pool_stats, _) = memory_manager.get_pool_stats();
102    println!("  - 字符串池操作: {}ms", pool_time.as_millis());
103    println!("  - 池大小: 小型={}, 大型={}, 总容量={}KB", 
104             pool_stats.small_pool_size,
105             pool_stats.large_pool_size, 
106             pool_stats.total_capacity / 1024);
107    
108    // 3. 智能缓存测试
109    println!("\n🧠 智能缓存性能:");
110    use html_translation_lib::config::TranslationConfig;
111    
112    let config = TranslationConfig::new()
113        .target_language("zh")
114        .api_url("http://example.com/translate");
115    
116    let mut cache_manager = SmartCacheManager::new(&config).await?;
117    
118    let start = Instant::now();
119    
120    // 模拟缓存操作
121    for i in 0..500 {
122        let key = format!("text_{}", i % 100); // 重复键以测试缓存命中
123        let value = format!("translation_{}", i);
124        cache_manager.set(&key, value).await?;
125    }
126    
127    // 测试缓存命中
128    let mut hits = 0;
129    for i in 0..100 {
130        let key = format!("text_{}", i);
131        if cache_manager.get(&key).await?.is_some() {
132            hits += 1;
133        }
134    }
135    
136    let cache_time = start.elapsed();
137    let cache_stats = cache_manager.stats();
138    
139    println!("  - 缓存操作时间: {}ms", cache_time.as_millis());
140    println!("  - 缓存命中数: {} / 100", hits);
141    println!("  - L1命中率: {:.1}%", cache_stats.l1_hit_rate() * 100.0);
142    println!("  - 总命中率: {:.1}%", cache_stats.hit_rate() * 100.0);
143    
144    // 4. 并发批处理测试
145    println!("\n⚡ 并发批处理性能:");
146    let batch_config = BatchConfig {
147        batch_size: 20,
148        max_concurrency: 4,
149        timeout_duration: std::time::Duration::from_secs(10),
150        ..Default::default()
151    };
152    
153    let batch_processor = ConcurrentBatchProcessor::new(
154        batch_config, 
155        Arc::clone(&memory_manager)
156    );
157    
158    // 准备测试文本
159    let test_texts: Vec<String> = (0..200)
160        .map(|i| format!("Test text number {}", i))
161        .collect();
162    
163    let start = Instant::now();
164    
165    // 提交批处理任务
166    let mut task_ids = Vec::new();
167    for chunk in test_texts.chunks(50) {
168        let task_id = batch_processor.submit_batch(
169            chunk.to_vec(), 
170            Priority::Normal
171        ).await?;
172        task_ids.push(task_id);
173    }
174    
175    // 模拟翻译函数
176    async fn mock_translate(texts: Vec<String>) -> html_translation_lib::error::TranslationResult<Vec<String>> {
177        tokio::time::sleep(std::time::Duration::from_millis(10)).await;
178        Ok(texts.into_iter().map(|t| format!("翻译_{}", t)).collect())
179    }
180    
181    // 处理队列
182    let _results = batch_processor.process_queue(mock_translate).await?;
183    let batch_time = start.elapsed();
184    
185    let batch_stats = batch_processor.get_stats().await;
186    let queue_status = batch_processor.get_queue_status();
187    
188    println!("  - 批处理总时间: {}ms", batch_time.as_millis());
189    println!("  - 处理成功率: {:.1}%", batch_stats.success_rate() * 100.0);
190    println!("  - 平均处理时间: {}ms", batch_stats.average_processing_time().as_millis());
191    println!("  - 吞吐量: {:.1} 任务/秒", batch_stats.throughput());
192    println!("  - 队列剩余: {} 任务", queue_status.total_tasks);
193    
194    // 5. 总结
195    println!("\n📈 性能优化总结:");
196    println!("  ✅ DOM遍历优化: {:.1}x 性能提升", speedup);
197    println!("  ✅ 内存池管理: 减少 GC 压力");
198    println!("  ✅ 智能缓存: {:.1}% 命中率", cache_stats.hit_rate() * 100.0);
199    println!("  ✅ 并发批处理: {:.1}% 成功率", batch_stats.success_rate() * 100.0);
200    println!("\n🎉 所有性能优化测试完成!");
201    
202    Ok(())
203}
Source

pub fn get_queue_status(&self) -> QueueStatus

获取队列状态

Examples found in repository?
examples/performance_test.rs (line 186)
51async fn main() -> Result<(), Box<dyn std::error::Error>> {
52    println!("🚀 HTML翻译库性能测试\n");
53    
54    let large_html = generate_large_html();
55    let dom = parse_html(&large_html);
56    
57    println!("📊 测试数据:");
58    println!("  - HTML大小: {} KB", large_html.len() / 1024);
59    println!("  - 包含 ~5000 个文本元素\n");
60    
61    // 1. DOM遍历性能测试
62    println!("🔍 DOM遍历性能对比:");
63    
64    // 原始递归收集器
65    let start = Instant::now();
66    let original_collector = TextCollector::new();
67    let original_items = original_collector.collect_from_dom(&dom)?;
68    let original_time = start.elapsed();
69    println!("  - 原始递归收集器: {}ms, 收集到 {} 项", 
70             original_time.as_millis(), original_items.len());
71    
72    // 优化的迭代收集器
73    let start = Instant::now();
74    let mut optimized_collector = OptimizedTextCollector::new();
75    let optimized_items = optimized_collector.collect_from_dom_optimized(&dom)?;
76    let optimized_time = start.elapsed();
77    println!("  - 优化迭代收集器: {}ms, 收集到 {} 项", 
78             optimized_time.as_millis(), optimized_items.len());
79    
80    let speedup = original_time.as_millis() as f64 / optimized_time.as_millis() as f64;
81    println!("  ✨ 性能提升: {:.2}x 倍速\n", speedup);
82    
83    // 2. 内存管理测试
84    println!("💾 内存管理优化:");
85    let memory_manager = Arc::new(GlobalMemoryManager::new());
86    
87    // 测试字符串池效率
88    let start = Instant::now();
89    let mut test_strings = Vec::new();
90    for i in 0..1000 {
91        let s = memory_manager.acquire_string(50);
92        test_strings.push(format!("Test string {}", i));
93    }
94    
95    for s in test_strings {
96        memory_manager.release_string(s);
97    }
98    let pool_time = start.elapsed();
99    
100    // 获取内存统计
101    let (pool_stats, _) = memory_manager.get_pool_stats();
102    println!("  - 字符串池操作: {}ms", pool_time.as_millis());
103    println!("  - 池大小: 小型={}, 大型={}, 总容量={}KB", 
104             pool_stats.small_pool_size,
105             pool_stats.large_pool_size, 
106             pool_stats.total_capacity / 1024);
107    
108    // 3. 智能缓存测试
109    println!("\n🧠 智能缓存性能:");
110    use html_translation_lib::config::TranslationConfig;
111    
112    let config = TranslationConfig::new()
113        .target_language("zh")
114        .api_url("http://example.com/translate");
115    
116    let mut cache_manager = SmartCacheManager::new(&config).await?;
117    
118    let start = Instant::now();
119    
120    // 模拟缓存操作
121    for i in 0..500 {
122        let key = format!("text_{}", i % 100); // 重复键以测试缓存命中
123        let value = format!("translation_{}", i);
124        cache_manager.set(&key, value).await?;
125    }
126    
127    // 测试缓存命中
128    let mut hits = 0;
129    for i in 0..100 {
130        let key = format!("text_{}", i);
131        if cache_manager.get(&key).await?.is_some() {
132            hits += 1;
133        }
134    }
135    
136    let cache_time = start.elapsed();
137    let cache_stats = cache_manager.stats();
138    
139    println!("  - 缓存操作时间: {}ms", cache_time.as_millis());
140    println!("  - 缓存命中数: {} / 100", hits);
141    println!("  - L1命中率: {:.1}%", cache_stats.l1_hit_rate() * 100.0);
142    println!("  - 总命中率: {:.1}%", cache_stats.hit_rate() * 100.0);
143    
144    // 4. 并发批处理测试
145    println!("\n⚡ 并发批处理性能:");
146    let batch_config = BatchConfig {
147        batch_size: 20,
148        max_concurrency: 4,
149        timeout_duration: std::time::Duration::from_secs(10),
150        ..Default::default()
151    };
152    
153    let batch_processor = ConcurrentBatchProcessor::new(
154        batch_config, 
155        Arc::clone(&memory_manager)
156    );
157    
158    // 准备测试文本
159    let test_texts: Vec<String> = (0..200)
160        .map(|i| format!("Test text number {}", i))
161        .collect();
162    
163    let start = Instant::now();
164    
165    // 提交批处理任务
166    let mut task_ids = Vec::new();
167    for chunk in test_texts.chunks(50) {
168        let task_id = batch_processor.submit_batch(
169            chunk.to_vec(), 
170            Priority::Normal
171        ).await?;
172        task_ids.push(task_id);
173    }
174    
175    // 模拟翻译函数
176    async fn mock_translate(texts: Vec<String>) -> html_translation_lib::error::TranslationResult<Vec<String>> {
177        tokio::time::sleep(std::time::Duration::from_millis(10)).await;
178        Ok(texts.into_iter().map(|t| format!("翻译_{}", t)).collect())
179    }
180    
181    // 处理队列
182    let _results = batch_processor.process_queue(mock_translate).await?;
183    let batch_time = start.elapsed();
184    
185    let batch_stats = batch_processor.get_stats().await;
186    let queue_status = batch_processor.get_queue_status();
187    
188    println!("  - 批处理总时间: {}ms", batch_time.as_millis());
189    println!("  - 处理成功率: {:.1}%", batch_stats.success_rate() * 100.0);
190    println!("  - 平均处理时间: {}ms", batch_stats.average_processing_time().as_millis());
191    println!("  - 吞吐量: {:.1} 任务/秒", batch_stats.throughput());
192    println!("  - 队列剩余: {} 任务", queue_status.total_tasks);
193    
194    // 5. 总结
195    println!("\n📈 性能优化总结:");
196    println!("  ✅ DOM遍历优化: {:.1}x 性能提升", speedup);
197    println!("  ✅ 内存池管理: 减少 GC 压力");
198    println!("  ✅ 智能缓存: {:.1}% 命中率", cache_stats.hit_rate() * 100.0);
199    println!("  ✅ 并发批处理: {:.1}% 成功率", batch_stats.success_rate() * 100.0);
200    println!("\n🎉 所有性能优化测试完成!");
201    
202    Ok(())
203}
Source

pub fn clear_queue(&self) -> usize

清空队列

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T> Instrument for T

Source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
Source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> PolicyExt for T
where T: ?Sized,

Source§

fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns Action::Follow only if self and other return Action::Follow. Read more
Source§

fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns Action::Follow if either self or other returns Action::Follow. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<T> WithSubscriber for T

Source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

impl<T> ErasedDestructor for T
where T: 'static,